From 5de39a2c22d3f635ddd68ef95c236b426a4c6796 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 11:39:28 -0600 Subject: [PATCH 01/87] sbox32_hash.h: Use legal C symbol names --- sbox32_hash.h | 514 +++++++++++++++++++++++++------------------------- 1 file changed, 257 insertions(+), 257 deletions(-) diff --git a/sbox32_hash.h b/sbox32_hash.h index 594431ba0d43..b4744037da97 100644 --- a/sbox32_hash.h +++ b/sbox32_hash.h @@ -110,1282 +110,1282 @@ #if SBOX32_MAX_LEN > 256 #error "SBOX32_MAX_LEN is set too high!" #elif SBOX32_MAX_LEN == 256 -#define case_256_SBOX32(hash,state,key) _SBOX32_CASE(256,hash,state,key) +#define case_256_SBOX32(hash,state,key) SBOX32_CASE_(256,hash,state,key) #else #define case_256_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 255 -#define case_255_SBOX32(hash,state,key) _SBOX32_CASE(255,hash,state,key) +#define case_255_SBOX32(hash,state,key) SBOX32_CASE_(255,hash,state,key) #else #define case_255_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 254 -#define case_254_SBOX32(hash,state,key) _SBOX32_CASE(254,hash,state,key) +#define case_254_SBOX32(hash,state,key) SBOX32_CASE_(254,hash,state,key) #else #define case_254_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 253 -#define case_253_SBOX32(hash,state,key) _SBOX32_CASE(253,hash,state,key) +#define case_253_SBOX32(hash,state,key) SBOX32_CASE_(253,hash,state,key) #else #define case_253_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 252 -#define case_252_SBOX32(hash,state,key) _SBOX32_CASE(252,hash,state,key) +#define case_252_SBOX32(hash,state,key) SBOX32_CASE_(252,hash,state,key) #else #define case_252_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 251 -#define case_251_SBOX32(hash,state,key) _SBOX32_CASE(251,hash,state,key) +#define case_251_SBOX32(hash,state,key) SBOX32_CASE_(251,hash,state,key) #else #define case_251_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 250 -#define case_250_SBOX32(hash,state,key) _SBOX32_CASE(250,hash,state,key) +#define case_250_SBOX32(hash,state,key) SBOX32_CASE_(250,hash,state,key) #else #define case_250_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 249 -#define case_249_SBOX32(hash,state,key) _SBOX32_CASE(249,hash,state,key) +#define case_249_SBOX32(hash,state,key) SBOX32_CASE_(249,hash,state,key) #else #define case_249_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 248 -#define case_248_SBOX32(hash,state,key) _SBOX32_CASE(248,hash,state,key) +#define case_248_SBOX32(hash,state,key) SBOX32_CASE_(248,hash,state,key) #else #define case_248_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 247 -#define case_247_SBOX32(hash,state,key) _SBOX32_CASE(247,hash,state,key) +#define case_247_SBOX32(hash,state,key) SBOX32_CASE_(247,hash,state,key) #else #define case_247_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 246 -#define case_246_SBOX32(hash,state,key) _SBOX32_CASE(246,hash,state,key) +#define case_246_SBOX32(hash,state,key) SBOX32_CASE_(246,hash,state,key) #else #define case_246_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 245 -#define case_245_SBOX32(hash,state,key) _SBOX32_CASE(245,hash,state,key) +#define case_245_SBOX32(hash,state,key) SBOX32_CASE_(245,hash,state,key) #else #define case_245_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 244 -#define case_244_SBOX32(hash,state,key) _SBOX32_CASE(244,hash,state,key) +#define case_244_SBOX32(hash,state,key) SBOX32_CASE_(244,hash,state,key) #else #define case_244_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 243 -#define case_243_SBOX32(hash,state,key) _SBOX32_CASE(243,hash,state,key) +#define case_243_SBOX32(hash,state,key) SBOX32_CASE_(243,hash,state,key) #else #define case_243_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 242 -#define case_242_SBOX32(hash,state,key) _SBOX32_CASE(242,hash,state,key) +#define case_242_SBOX32(hash,state,key) SBOX32_CASE_(242,hash,state,key) #else #define case_242_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 241 -#define case_241_SBOX32(hash,state,key) _SBOX32_CASE(241,hash,state,key) +#define case_241_SBOX32(hash,state,key) SBOX32_CASE_(241,hash,state,key) #else #define case_241_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 240 -#define case_240_SBOX32(hash,state,key) _SBOX32_CASE(240,hash,state,key) +#define case_240_SBOX32(hash,state,key) SBOX32_CASE_(240,hash,state,key) #else #define case_240_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 239 -#define case_239_SBOX32(hash,state,key) _SBOX32_CASE(239,hash,state,key) +#define case_239_SBOX32(hash,state,key) SBOX32_CASE_(239,hash,state,key) #else #define case_239_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 238 -#define case_238_SBOX32(hash,state,key) _SBOX32_CASE(238,hash,state,key) +#define case_238_SBOX32(hash,state,key) SBOX32_CASE_(238,hash,state,key) #else #define case_238_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 237 -#define case_237_SBOX32(hash,state,key) _SBOX32_CASE(237,hash,state,key) +#define case_237_SBOX32(hash,state,key) SBOX32_CASE_(237,hash,state,key) #else #define case_237_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 236 -#define case_236_SBOX32(hash,state,key) _SBOX32_CASE(236,hash,state,key) +#define case_236_SBOX32(hash,state,key) SBOX32_CASE_(236,hash,state,key) #else #define case_236_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 235 -#define case_235_SBOX32(hash,state,key) _SBOX32_CASE(235,hash,state,key) +#define case_235_SBOX32(hash,state,key) SBOX32_CASE_(235,hash,state,key) #else #define case_235_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 234 -#define case_234_SBOX32(hash,state,key) _SBOX32_CASE(234,hash,state,key) +#define case_234_SBOX32(hash,state,key) SBOX32_CASE_(234,hash,state,key) #else #define case_234_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 233 -#define case_233_SBOX32(hash,state,key) _SBOX32_CASE(233,hash,state,key) +#define case_233_SBOX32(hash,state,key) SBOX32_CASE_(233,hash,state,key) #else #define case_233_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 232 -#define case_232_SBOX32(hash,state,key) _SBOX32_CASE(232,hash,state,key) +#define case_232_SBOX32(hash,state,key) SBOX32_CASE_(232,hash,state,key) #else #define case_232_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 231 -#define case_231_SBOX32(hash,state,key) _SBOX32_CASE(231,hash,state,key) +#define case_231_SBOX32(hash,state,key) SBOX32_CASE_(231,hash,state,key) #else #define case_231_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 230 -#define case_230_SBOX32(hash,state,key) _SBOX32_CASE(230,hash,state,key) +#define case_230_SBOX32(hash,state,key) SBOX32_CASE_(230,hash,state,key) #else #define case_230_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 229 -#define case_229_SBOX32(hash,state,key) _SBOX32_CASE(229,hash,state,key) +#define case_229_SBOX32(hash,state,key) SBOX32_CASE_(229,hash,state,key) #else #define case_229_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 228 -#define case_228_SBOX32(hash,state,key) _SBOX32_CASE(228,hash,state,key) +#define case_228_SBOX32(hash,state,key) SBOX32_CASE_(228,hash,state,key) #else #define case_228_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 227 -#define case_227_SBOX32(hash,state,key) _SBOX32_CASE(227,hash,state,key) +#define case_227_SBOX32(hash,state,key) SBOX32_CASE_(227,hash,state,key) #else #define case_227_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 226 -#define case_226_SBOX32(hash,state,key) _SBOX32_CASE(226,hash,state,key) +#define case_226_SBOX32(hash,state,key) SBOX32_CASE_(226,hash,state,key) #else #define case_226_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 225 -#define case_225_SBOX32(hash,state,key) _SBOX32_CASE(225,hash,state,key) +#define case_225_SBOX32(hash,state,key) SBOX32_CASE_(225,hash,state,key) #else #define case_225_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 224 -#define case_224_SBOX32(hash,state,key) _SBOX32_CASE(224,hash,state,key) +#define case_224_SBOX32(hash,state,key) SBOX32_CASE_(224,hash,state,key) #else #define case_224_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 223 -#define case_223_SBOX32(hash,state,key) _SBOX32_CASE(223,hash,state,key) +#define case_223_SBOX32(hash,state,key) SBOX32_CASE_(223,hash,state,key) #else #define case_223_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 222 -#define case_222_SBOX32(hash,state,key) _SBOX32_CASE(222,hash,state,key) +#define case_222_SBOX32(hash,state,key) SBOX32_CASE_(222,hash,state,key) #else #define case_222_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 221 -#define case_221_SBOX32(hash,state,key) _SBOX32_CASE(221,hash,state,key) +#define case_221_SBOX32(hash,state,key) SBOX32_CASE_(221,hash,state,key) #else #define case_221_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 220 -#define case_220_SBOX32(hash,state,key) _SBOX32_CASE(220,hash,state,key) +#define case_220_SBOX32(hash,state,key) SBOX32_CASE_(220,hash,state,key) #else #define case_220_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 219 -#define case_219_SBOX32(hash,state,key) _SBOX32_CASE(219,hash,state,key) +#define case_219_SBOX32(hash,state,key) SBOX32_CASE_(219,hash,state,key) #else #define case_219_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 218 -#define case_218_SBOX32(hash,state,key) _SBOX32_CASE(218,hash,state,key) +#define case_218_SBOX32(hash,state,key) SBOX32_CASE_(218,hash,state,key) #else #define case_218_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 217 -#define case_217_SBOX32(hash,state,key) _SBOX32_CASE(217,hash,state,key) +#define case_217_SBOX32(hash,state,key) SBOX32_CASE_(217,hash,state,key) #else #define case_217_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 216 -#define case_216_SBOX32(hash,state,key) _SBOX32_CASE(216,hash,state,key) +#define case_216_SBOX32(hash,state,key) SBOX32_CASE_(216,hash,state,key) #else #define case_216_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 215 -#define case_215_SBOX32(hash,state,key) _SBOX32_CASE(215,hash,state,key) +#define case_215_SBOX32(hash,state,key) SBOX32_CASE_(215,hash,state,key) #else #define case_215_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 214 -#define case_214_SBOX32(hash,state,key) _SBOX32_CASE(214,hash,state,key) +#define case_214_SBOX32(hash,state,key) SBOX32_CASE_(214,hash,state,key) #else #define case_214_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 213 -#define case_213_SBOX32(hash,state,key) _SBOX32_CASE(213,hash,state,key) +#define case_213_SBOX32(hash,state,key) SBOX32_CASE_(213,hash,state,key) #else #define case_213_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 212 -#define case_212_SBOX32(hash,state,key) _SBOX32_CASE(212,hash,state,key) +#define case_212_SBOX32(hash,state,key) SBOX32_CASE_(212,hash,state,key) #else #define case_212_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 211 -#define case_211_SBOX32(hash,state,key) _SBOX32_CASE(211,hash,state,key) +#define case_211_SBOX32(hash,state,key) SBOX32_CASE_(211,hash,state,key) #else #define case_211_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 210 -#define case_210_SBOX32(hash,state,key) _SBOX32_CASE(210,hash,state,key) +#define case_210_SBOX32(hash,state,key) SBOX32_CASE_(210,hash,state,key) #else #define case_210_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 209 -#define case_209_SBOX32(hash,state,key) _SBOX32_CASE(209,hash,state,key) +#define case_209_SBOX32(hash,state,key) SBOX32_CASE_(209,hash,state,key) #else #define case_209_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 208 -#define case_208_SBOX32(hash,state,key) _SBOX32_CASE(208,hash,state,key) +#define case_208_SBOX32(hash,state,key) SBOX32_CASE_(208,hash,state,key) #else #define case_208_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 207 -#define case_207_SBOX32(hash,state,key) _SBOX32_CASE(207,hash,state,key) +#define case_207_SBOX32(hash,state,key) SBOX32_CASE_(207,hash,state,key) #else #define case_207_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 206 -#define case_206_SBOX32(hash,state,key) _SBOX32_CASE(206,hash,state,key) +#define case_206_SBOX32(hash,state,key) SBOX32_CASE_(206,hash,state,key) #else #define case_206_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 205 -#define case_205_SBOX32(hash,state,key) _SBOX32_CASE(205,hash,state,key) +#define case_205_SBOX32(hash,state,key) SBOX32_CASE_(205,hash,state,key) #else #define case_205_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 204 -#define case_204_SBOX32(hash,state,key) _SBOX32_CASE(204,hash,state,key) +#define case_204_SBOX32(hash,state,key) SBOX32_CASE_(204,hash,state,key) #else #define case_204_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 203 -#define case_203_SBOX32(hash,state,key) _SBOX32_CASE(203,hash,state,key) +#define case_203_SBOX32(hash,state,key) SBOX32_CASE_(203,hash,state,key) #else #define case_203_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 202 -#define case_202_SBOX32(hash,state,key) _SBOX32_CASE(202,hash,state,key) +#define case_202_SBOX32(hash,state,key) SBOX32_CASE_(202,hash,state,key) #else #define case_202_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 201 -#define case_201_SBOX32(hash,state,key) _SBOX32_CASE(201,hash,state,key) +#define case_201_SBOX32(hash,state,key) SBOX32_CASE_(201,hash,state,key) #else #define case_201_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 200 -#define case_200_SBOX32(hash,state,key) _SBOX32_CASE(200,hash,state,key) +#define case_200_SBOX32(hash,state,key) SBOX32_CASE_(200,hash,state,key) #else #define case_200_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 199 -#define case_199_SBOX32(hash,state,key) _SBOX32_CASE(199,hash,state,key) +#define case_199_SBOX32(hash,state,key) SBOX32_CASE_(199,hash,state,key) #else #define case_199_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 198 -#define case_198_SBOX32(hash,state,key) _SBOX32_CASE(198,hash,state,key) +#define case_198_SBOX32(hash,state,key) SBOX32_CASE_(198,hash,state,key) #else #define case_198_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 197 -#define case_197_SBOX32(hash,state,key) _SBOX32_CASE(197,hash,state,key) +#define case_197_SBOX32(hash,state,key) SBOX32_CASE_(197,hash,state,key) #else #define case_197_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 196 -#define case_196_SBOX32(hash,state,key) _SBOX32_CASE(196,hash,state,key) +#define case_196_SBOX32(hash,state,key) SBOX32_CASE_(196,hash,state,key) #else #define case_196_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 195 -#define case_195_SBOX32(hash,state,key) _SBOX32_CASE(195,hash,state,key) +#define case_195_SBOX32(hash,state,key) SBOX32_CASE_(195,hash,state,key) #else #define case_195_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 194 -#define case_194_SBOX32(hash,state,key) _SBOX32_CASE(194,hash,state,key) +#define case_194_SBOX32(hash,state,key) SBOX32_CASE_(194,hash,state,key) #else #define case_194_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 193 -#define case_193_SBOX32(hash,state,key) _SBOX32_CASE(193,hash,state,key) +#define case_193_SBOX32(hash,state,key) SBOX32_CASE_(193,hash,state,key) #else #define case_193_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 192 -#define case_192_SBOX32(hash,state,key) _SBOX32_CASE(192,hash,state,key) +#define case_192_SBOX32(hash,state,key) SBOX32_CASE_(192,hash,state,key) #else #define case_192_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 191 -#define case_191_SBOX32(hash,state,key) _SBOX32_CASE(191,hash,state,key) +#define case_191_SBOX32(hash,state,key) SBOX32_CASE_(191,hash,state,key) #else #define case_191_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 190 -#define case_190_SBOX32(hash,state,key) _SBOX32_CASE(190,hash,state,key) +#define case_190_SBOX32(hash,state,key) SBOX32_CASE_(190,hash,state,key) #else #define case_190_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 189 -#define case_189_SBOX32(hash,state,key) _SBOX32_CASE(189,hash,state,key) +#define case_189_SBOX32(hash,state,key) SBOX32_CASE_(189,hash,state,key) #else #define case_189_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 188 -#define case_188_SBOX32(hash,state,key) _SBOX32_CASE(188,hash,state,key) +#define case_188_SBOX32(hash,state,key) SBOX32_CASE_(188,hash,state,key) #else #define case_188_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 187 -#define case_187_SBOX32(hash,state,key) _SBOX32_CASE(187,hash,state,key) +#define case_187_SBOX32(hash,state,key) SBOX32_CASE_(187,hash,state,key) #else #define case_187_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 186 -#define case_186_SBOX32(hash,state,key) _SBOX32_CASE(186,hash,state,key) +#define case_186_SBOX32(hash,state,key) SBOX32_CASE_(186,hash,state,key) #else #define case_186_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 185 -#define case_185_SBOX32(hash,state,key) _SBOX32_CASE(185,hash,state,key) +#define case_185_SBOX32(hash,state,key) SBOX32_CASE_(185,hash,state,key) #else #define case_185_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 184 -#define case_184_SBOX32(hash,state,key) _SBOX32_CASE(184,hash,state,key) +#define case_184_SBOX32(hash,state,key) SBOX32_CASE_(184,hash,state,key) #else #define case_184_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 183 -#define case_183_SBOX32(hash,state,key) _SBOX32_CASE(183,hash,state,key) +#define case_183_SBOX32(hash,state,key) SBOX32_CASE_(183,hash,state,key) #else #define case_183_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 182 -#define case_182_SBOX32(hash,state,key) _SBOX32_CASE(182,hash,state,key) +#define case_182_SBOX32(hash,state,key) SBOX32_CASE_(182,hash,state,key) #else #define case_182_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 181 -#define case_181_SBOX32(hash,state,key) _SBOX32_CASE(181,hash,state,key) +#define case_181_SBOX32(hash,state,key) SBOX32_CASE_(181,hash,state,key) #else #define case_181_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 180 -#define case_180_SBOX32(hash,state,key) _SBOX32_CASE(180,hash,state,key) +#define case_180_SBOX32(hash,state,key) SBOX32_CASE_(180,hash,state,key) #else #define case_180_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 179 -#define case_179_SBOX32(hash,state,key) _SBOX32_CASE(179,hash,state,key) +#define case_179_SBOX32(hash,state,key) SBOX32_CASE_(179,hash,state,key) #else #define case_179_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 178 -#define case_178_SBOX32(hash,state,key) _SBOX32_CASE(178,hash,state,key) +#define case_178_SBOX32(hash,state,key) SBOX32_CASE_(178,hash,state,key) #else #define case_178_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 177 -#define case_177_SBOX32(hash,state,key) _SBOX32_CASE(177,hash,state,key) +#define case_177_SBOX32(hash,state,key) SBOX32_CASE_(177,hash,state,key) #else #define case_177_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 176 -#define case_176_SBOX32(hash,state,key) _SBOX32_CASE(176,hash,state,key) +#define case_176_SBOX32(hash,state,key) SBOX32_CASE_(176,hash,state,key) #else #define case_176_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 175 -#define case_175_SBOX32(hash,state,key) _SBOX32_CASE(175,hash,state,key) +#define case_175_SBOX32(hash,state,key) SBOX32_CASE_(175,hash,state,key) #else #define case_175_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 174 -#define case_174_SBOX32(hash,state,key) _SBOX32_CASE(174,hash,state,key) +#define case_174_SBOX32(hash,state,key) SBOX32_CASE_(174,hash,state,key) #else #define case_174_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 173 -#define case_173_SBOX32(hash,state,key) _SBOX32_CASE(173,hash,state,key) +#define case_173_SBOX32(hash,state,key) SBOX32_CASE_(173,hash,state,key) #else #define case_173_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 172 -#define case_172_SBOX32(hash,state,key) _SBOX32_CASE(172,hash,state,key) +#define case_172_SBOX32(hash,state,key) SBOX32_CASE_(172,hash,state,key) #else #define case_172_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 171 -#define case_171_SBOX32(hash,state,key) _SBOX32_CASE(171,hash,state,key) +#define case_171_SBOX32(hash,state,key) SBOX32_CASE_(171,hash,state,key) #else #define case_171_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 170 -#define case_170_SBOX32(hash,state,key) _SBOX32_CASE(170,hash,state,key) +#define case_170_SBOX32(hash,state,key) SBOX32_CASE_(170,hash,state,key) #else #define case_170_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 169 -#define case_169_SBOX32(hash,state,key) _SBOX32_CASE(169,hash,state,key) +#define case_169_SBOX32(hash,state,key) SBOX32_CASE_(169,hash,state,key) #else #define case_169_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 168 -#define case_168_SBOX32(hash,state,key) _SBOX32_CASE(168,hash,state,key) +#define case_168_SBOX32(hash,state,key) SBOX32_CASE_(168,hash,state,key) #else #define case_168_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 167 -#define case_167_SBOX32(hash,state,key) _SBOX32_CASE(167,hash,state,key) +#define case_167_SBOX32(hash,state,key) SBOX32_CASE_(167,hash,state,key) #else #define case_167_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 166 -#define case_166_SBOX32(hash,state,key) _SBOX32_CASE(166,hash,state,key) +#define case_166_SBOX32(hash,state,key) SBOX32_CASE_(166,hash,state,key) #else #define case_166_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 165 -#define case_165_SBOX32(hash,state,key) _SBOX32_CASE(165,hash,state,key) +#define case_165_SBOX32(hash,state,key) SBOX32_CASE_(165,hash,state,key) #else #define case_165_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 164 -#define case_164_SBOX32(hash,state,key) _SBOX32_CASE(164,hash,state,key) +#define case_164_SBOX32(hash,state,key) SBOX32_CASE_(164,hash,state,key) #else #define case_164_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 163 -#define case_163_SBOX32(hash,state,key) _SBOX32_CASE(163,hash,state,key) +#define case_163_SBOX32(hash,state,key) SBOX32_CASE_(163,hash,state,key) #else #define case_163_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 162 -#define case_162_SBOX32(hash,state,key) _SBOX32_CASE(162,hash,state,key) +#define case_162_SBOX32(hash,state,key) SBOX32_CASE_(162,hash,state,key) #else #define case_162_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 161 -#define case_161_SBOX32(hash,state,key) _SBOX32_CASE(161,hash,state,key) +#define case_161_SBOX32(hash,state,key) SBOX32_CASE_(161,hash,state,key) #else #define case_161_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 160 -#define case_160_SBOX32(hash,state,key) _SBOX32_CASE(160,hash,state,key) +#define case_160_SBOX32(hash,state,key) SBOX32_CASE_(160,hash,state,key) #else #define case_160_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 159 -#define case_159_SBOX32(hash,state,key) _SBOX32_CASE(159,hash,state,key) +#define case_159_SBOX32(hash,state,key) SBOX32_CASE_(159,hash,state,key) #else #define case_159_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 158 -#define case_158_SBOX32(hash,state,key) _SBOX32_CASE(158,hash,state,key) +#define case_158_SBOX32(hash,state,key) SBOX32_CASE_(158,hash,state,key) #else #define case_158_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 157 -#define case_157_SBOX32(hash,state,key) _SBOX32_CASE(157,hash,state,key) +#define case_157_SBOX32(hash,state,key) SBOX32_CASE_(157,hash,state,key) #else #define case_157_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 156 -#define case_156_SBOX32(hash,state,key) _SBOX32_CASE(156,hash,state,key) +#define case_156_SBOX32(hash,state,key) SBOX32_CASE_(156,hash,state,key) #else #define case_156_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 155 -#define case_155_SBOX32(hash,state,key) _SBOX32_CASE(155,hash,state,key) +#define case_155_SBOX32(hash,state,key) SBOX32_CASE_(155,hash,state,key) #else #define case_155_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 154 -#define case_154_SBOX32(hash,state,key) _SBOX32_CASE(154,hash,state,key) +#define case_154_SBOX32(hash,state,key) SBOX32_CASE_(154,hash,state,key) #else #define case_154_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 153 -#define case_153_SBOX32(hash,state,key) _SBOX32_CASE(153,hash,state,key) +#define case_153_SBOX32(hash,state,key) SBOX32_CASE_(153,hash,state,key) #else #define case_153_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 152 -#define case_152_SBOX32(hash,state,key) _SBOX32_CASE(152,hash,state,key) +#define case_152_SBOX32(hash,state,key) SBOX32_CASE_(152,hash,state,key) #else #define case_152_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 151 -#define case_151_SBOX32(hash,state,key) _SBOX32_CASE(151,hash,state,key) +#define case_151_SBOX32(hash,state,key) SBOX32_CASE_(151,hash,state,key) #else #define case_151_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 150 -#define case_150_SBOX32(hash,state,key) _SBOX32_CASE(150,hash,state,key) +#define case_150_SBOX32(hash,state,key) SBOX32_CASE_(150,hash,state,key) #else #define case_150_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 149 -#define case_149_SBOX32(hash,state,key) _SBOX32_CASE(149,hash,state,key) +#define case_149_SBOX32(hash,state,key) SBOX32_CASE_(149,hash,state,key) #else #define case_149_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 148 -#define case_148_SBOX32(hash,state,key) _SBOX32_CASE(148,hash,state,key) +#define case_148_SBOX32(hash,state,key) SBOX32_CASE_(148,hash,state,key) #else #define case_148_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 147 -#define case_147_SBOX32(hash,state,key) _SBOX32_CASE(147,hash,state,key) +#define case_147_SBOX32(hash,state,key) SBOX32_CASE_(147,hash,state,key) #else #define case_147_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 146 -#define case_146_SBOX32(hash,state,key) _SBOX32_CASE(146,hash,state,key) +#define case_146_SBOX32(hash,state,key) SBOX32_CASE_(146,hash,state,key) #else #define case_146_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 145 -#define case_145_SBOX32(hash,state,key) _SBOX32_CASE(145,hash,state,key) +#define case_145_SBOX32(hash,state,key) SBOX32_CASE_(145,hash,state,key) #else #define case_145_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 144 -#define case_144_SBOX32(hash,state,key) _SBOX32_CASE(144,hash,state,key) +#define case_144_SBOX32(hash,state,key) SBOX32_CASE_(144,hash,state,key) #else #define case_144_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 143 -#define case_143_SBOX32(hash,state,key) _SBOX32_CASE(143,hash,state,key) +#define case_143_SBOX32(hash,state,key) SBOX32_CASE_(143,hash,state,key) #else #define case_143_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 142 -#define case_142_SBOX32(hash,state,key) _SBOX32_CASE(142,hash,state,key) +#define case_142_SBOX32(hash,state,key) SBOX32_CASE_(142,hash,state,key) #else #define case_142_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 141 -#define case_141_SBOX32(hash,state,key) _SBOX32_CASE(141,hash,state,key) +#define case_141_SBOX32(hash,state,key) SBOX32_CASE_(141,hash,state,key) #else #define case_141_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 140 -#define case_140_SBOX32(hash,state,key) _SBOX32_CASE(140,hash,state,key) +#define case_140_SBOX32(hash,state,key) SBOX32_CASE_(140,hash,state,key) #else #define case_140_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 139 -#define case_139_SBOX32(hash,state,key) _SBOX32_CASE(139,hash,state,key) +#define case_139_SBOX32(hash,state,key) SBOX32_CASE_(139,hash,state,key) #else #define case_139_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 138 -#define case_138_SBOX32(hash,state,key) _SBOX32_CASE(138,hash,state,key) +#define case_138_SBOX32(hash,state,key) SBOX32_CASE_(138,hash,state,key) #else #define case_138_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 137 -#define case_137_SBOX32(hash,state,key) _SBOX32_CASE(137,hash,state,key) +#define case_137_SBOX32(hash,state,key) SBOX32_CASE_(137,hash,state,key) #else #define case_137_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 136 -#define case_136_SBOX32(hash,state,key) _SBOX32_CASE(136,hash,state,key) +#define case_136_SBOX32(hash,state,key) SBOX32_CASE_(136,hash,state,key) #else #define case_136_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 135 -#define case_135_SBOX32(hash,state,key) _SBOX32_CASE(135,hash,state,key) +#define case_135_SBOX32(hash,state,key) SBOX32_CASE_(135,hash,state,key) #else #define case_135_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 134 -#define case_134_SBOX32(hash,state,key) _SBOX32_CASE(134,hash,state,key) +#define case_134_SBOX32(hash,state,key) SBOX32_CASE_(134,hash,state,key) #else #define case_134_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 133 -#define case_133_SBOX32(hash,state,key) _SBOX32_CASE(133,hash,state,key) +#define case_133_SBOX32(hash,state,key) SBOX32_CASE_(133,hash,state,key) #else #define case_133_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 132 -#define case_132_SBOX32(hash,state,key) _SBOX32_CASE(132,hash,state,key) +#define case_132_SBOX32(hash,state,key) SBOX32_CASE_(132,hash,state,key) #else #define case_132_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 131 -#define case_131_SBOX32(hash,state,key) _SBOX32_CASE(131,hash,state,key) +#define case_131_SBOX32(hash,state,key) SBOX32_CASE_(131,hash,state,key) #else #define case_131_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 130 -#define case_130_SBOX32(hash,state,key) _SBOX32_CASE(130,hash,state,key) +#define case_130_SBOX32(hash,state,key) SBOX32_CASE_(130,hash,state,key) #else #define case_130_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 129 -#define case_129_SBOX32(hash,state,key) _SBOX32_CASE(129,hash,state,key) +#define case_129_SBOX32(hash,state,key) SBOX32_CASE_(129,hash,state,key) #else #define case_129_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 128 -#define case_128_SBOX32(hash,state,key) _SBOX32_CASE(128,hash,state,key) +#define case_128_SBOX32(hash,state,key) SBOX32_CASE_(128,hash,state,key) #else #define case_128_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 127 -#define case_127_SBOX32(hash,state,key) _SBOX32_CASE(127,hash,state,key) +#define case_127_SBOX32(hash,state,key) SBOX32_CASE_(127,hash,state,key) #else #define case_127_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 126 -#define case_126_SBOX32(hash,state,key) _SBOX32_CASE(126,hash,state,key) +#define case_126_SBOX32(hash,state,key) SBOX32_CASE_(126,hash,state,key) #else #define case_126_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 125 -#define case_125_SBOX32(hash,state,key) _SBOX32_CASE(125,hash,state,key) +#define case_125_SBOX32(hash,state,key) SBOX32_CASE_(125,hash,state,key) #else #define case_125_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 124 -#define case_124_SBOX32(hash,state,key) _SBOX32_CASE(124,hash,state,key) +#define case_124_SBOX32(hash,state,key) SBOX32_CASE_(124,hash,state,key) #else #define case_124_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 123 -#define case_123_SBOX32(hash,state,key) _SBOX32_CASE(123,hash,state,key) +#define case_123_SBOX32(hash,state,key) SBOX32_CASE_(123,hash,state,key) #else #define case_123_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 122 -#define case_122_SBOX32(hash,state,key) _SBOX32_CASE(122,hash,state,key) +#define case_122_SBOX32(hash,state,key) SBOX32_CASE_(122,hash,state,key) #else #define case_122_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 121 -#define case_121_SBOX32(hash,state,key) _SBOX32_CASE(121,hash,state,key) +#define case_121_SBOX32(hash,state,key) SBOX32_CASE_(121,hash,state,key) #else #define case_121_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 120 -#define case_120_SBOX32(hash,state,key) _SBOX32_CASE(120,hash,state,key) +#define case_120_SBOX32(hash,state,key) SBOX32_CASE_(120,hash,state,key) #else #define case_120_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 119 -#define case_119_SBOX32(hash,state,key) _SBOX32_CASE(119,hash,state,key) +#define case_119_SBOX32(hash,state,key) SBOX32_CASE_(119,hash,state,key) #else #define case_119_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 118 -#define case_118_SBOX32(hash,state,key) _SBOX32_CASE(118,hash,state,key) +#define case_118_SBOX32(hash,state,key) SBOX32_CASE_(118,hash,state,key) #else #define case_118_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 117 -#define case_117_SBOX32(hash,state,key) _SBOX32_CASE(117,hash,state,key) +#define case_117_SBOX32(hash,state,key) SBOX32_CASE_(117,hash,state,key) #else #define case_117_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 116 -#define case_116_SBOX32(hash,state,key) _SBOX32_CASE(116,hash,state,key) +#define case_116_SBOX32(hash,state,key) SBOX32_CASE_(116,hash,state,key) #else #define case_116_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 115 -#define case_115_SBOX32(hash,state,key) _SBOX32_CASE(115,hash,state,key) +#define case_115_SBOX32(hash,state,key) SBOX32_CASE_(115,hash,state,key) #else #define case_115_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 114 -#define case_114_SBOX32(hash,state,key) _SBOX32_CASE(114,hash,state,key) +#define case_114_SBOX32(hash,state,key) SBOX32_CASE_(114,hash,state,key) #else #define case_114_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 113 -#define case_113_SBOX32(hash,state,key) _SBOX32_CASE(113,hash,state,key) +#define case_113_SBOX32(hash,state,key) SBOX32_CASE_(113,hash,state,key) #else #define case_113_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 112 -#define case_112_SBOX32(hash,state,key) _SBOX32_CASE(112,hash,state,key) +#define case_112_SBOX32(hash,state,key) SBOX32_CASE_(112,hash,state,key) #else #define case_112_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 111 -#define case_111_SBOX32(hash,state,key) _SBOX32_CASE(111,hash,state,key) +#define case_111_SBOX32(hash,state,key) SBOX32_CASE_(111,hash,state,key) #else #define case_111_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 110 -#define case_110_SBOX32(hash,state,key) _SBOX32_CASE(110,hash,state,key) +#define case_110_SBOX32(hash,state,key) SBOX32_CASE_(110,hash,state,key) #else #define case_110_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 109 -#define case_109_SBOX32(hash,state,key) _SBOX32_CASE(109,hash,state,key) +#define case_109_SBOX32(hash,state,key) SBOX32_CASE_(109,hash,state,key) #else #define case_109_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 108 -#define case_108_SBOX32(hash,state,key) _SBOX32_CASE(108,hash,state,key) +#define case_108_SBOX32(hash,state,key) SBOX32_CASE_(108,hash,state,key) #else #define case_108_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 107 -#define case_107_SBOX32(hash,state,key) _SBOX32_CASE(107,hash,state,key) +#define case_107_SBOX32(hash,state,key) SBOX32_CASE_(107,hash,state,key) #else #define case_107_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 106 -#define case_106_SBOX32(hash,state,key) _SBOX32_CASE(106,hash,state,key) +#define case_106_SBOX32(hash,state,key) SBOX32_CASE_(106,hash,state,key) #else #define case_106_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 105 -#define case_105_SBOX32(hash,state,key) _SBOX32_CASE(105,hash,state,key) +#define case_105_SBOX32(hash,state,key) SBOX32_CASE_(105,hash,state,key) #else #define case_105_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 104 -#define case_104_SBOX32(hash,state,key) _SBOX32_CASE(104,hash,state,key) +#define case_104_SBOX32(hash,state,key) SBOX32_CASE_(104,hash,state,key) #else #define case_104_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 103 -#define case_103_SBOX32(hash,state,key) _SBOX32_CASE(103,hash,state,key) +#define case_103_SBOX32(hash,state,key) SBOX32_CASE_(103,hash,state,key) #else #define case_103_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 102 -#define case_102_SBOX32(hash,state,key) _SBOX32_CASE(102,hash,state,key) +#define case_102_SBOX32(hash,state,key) SBOX32_CASE_(102,hash,state,key) #else #define case_102_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 101 -#define case_101_SBOX32(hash,state,key) _SBOX32_CASE(101,hash,state,key) +#define case_101_SBOX32(hash,state,key) SBOX32_CASE_(101,hash,state,key) #else #define case_101_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 100 -#define case_100_SBOX32(hash,state,key) _SBOX32_CASE(100,hash,state,key) +#define case_100_SBOX32(hash,state,key) SBOX32_CASE_(100,hash,state,key) #else #define case_100_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 99 -#define case_99_SBOX32(hash,state,key) _SBOX32_CASE(99,hash,state,key) +#define case_99_SBOX32(hash,state,key) SBOX32_CASE_(99,hash,state,key) #else #define case_99_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 98 -#define case_98_SBOX32(hash,state,key) _SBOX32_CASE(98,hash,state,key) +#define case_98_SBOX32(hash,state,key) SBOX32_CASE_(98,hash,state,key) #else #define case_98_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 97 -#define case_97_SBOX32(hash,state,key) _SBOX32_CASE(97,hash,state,key) +#define case_97_SBOX32(hash,state,key) SBOX32_CASE_(97,hash,state,key) #else #define case_97_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 96 -#define case_96_SBOX32(hash,state,key) _SBOX32_CASE(96,hash,state,key) +#define case_96_SBOX32(hash,state,key) SBOX32_CASE_(96,hash,state,key) #else #define case_96_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 95 -#define case_95_SBOX32(hash,state,key) _SBOX32_CASE(95,hash,state,key) +#define case_95_SBOX32(hash,state,key) SBOX32_CASE_(95,hash,state,key) #else #define case_95_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 94 -#define case_94_SBOX32(hash,state,key) _SBOX32_CASE(94,hash,state,key) +#define case_94_SBOX32(hash,state,key) SBOX32_CASE_(94,hash,state,key) #else #define case_94_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 93 -#define case_93_SBOX32(hash,state,key) _SBOX32_CASE(93,hash,state,key) +#define case_93_SBOX32(hash,state,key) SBOX32_CASE_(93,hash,state,key) #else #define case_93_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 92 -#define case_92_SBOX32(hash,state,key) _SBOX32_CASE(92,hash,state,key) +#define case_92_SBOX32(hash,state,key) SBOX32_CASE_(92,hash,state,key) #else #define case_92_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 91 -#define case_91_SBOX32(hash,state,key) _SBOX32_CASE(91,hash,state,key) +#define case_91_SBOX32(hash,state,key) SBOX32_CASE_(91,hash,state,key) #else #define case_91_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 90 -#define case_90_SBOX32(hash,state,key) _SBOX32_CASE(90,hash,state,key) +#define case_90_SBOX32(hash,state,key) SBOX32_CASE_(90,hash,state,key) #else #define case_90_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 89 -#define case_89_SBOX32(hash,state,key) _SBOX32_CASE(89,hash,state,key) +#define case_89_SBOX32(hash,state,key) SBOX32_CASE_(89,hash,state,key) #else #define case_89_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 88 -#define case_88_SBOX32(hash,state,key) _SBOX32_CASE(88,hash,state,key) +#define case_88_SBOX32(hash,state,key) SBOX32_CASE_(88,hash,state,key) #else #define case_88_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 87 -#define case_87_SBOX32(hash,state,key) _SBOX32_CASE(87,hash,state,key) +#define case_87_SBOX32(hash,state,key) SBOX32_CASE_(87,hash,state,key) #else #define case_87_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 86 -#define case_86_SBOX32(hash,state,key) _SBOX32_CASE(86,hash,state,key) +#define case_86_SBOX32(hash,state,key) SBOX32_CASE_(86,hash,state,key) #else #define case_86_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 85 -#define case_85_SBOX32(hash,state,key) _SBOX32_CASE(85,hash,state,key) +#define case_85_SBOX32(hash,state,key) SBOX32_CASE_(85,hash,state,key) #else #define case_85_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 84 -#define case_84_SBOX32(hash,state,key) _SBOX32_CASE(84,hash,state,key) +#define case_84_SBOX32(hash,state,key) SBOX32_CASE_(84,hash,state,key) #else #define case_84_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 83 -#define case_83_SBOX32(hash,state,key) _SBOX32_CASE(83,hash,state,key) +#define case_83_SBOX32(hash,state,key) SBOX32_CASE_(83,hash,state,key) #else #define case_83_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 82 -#define case_82_SBOX32(hash,state,key) _SBOX32_CASE(82,hash,state,key) +#define case_82_SBOX32(hash,state,key) SBOX32_CASE_(82,hash,state,key) #else #define case_82_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 81 -#define case_81_SBOX32(hash,state,key) _SBOX32_CASE(81,hash,state,key) +#define case_81_SBOX32(hash,state,key) SBOX32_CASE_(81,hash,state,key) #else #define case_81_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 80 -#define case_80_SBOX32(hash,state,key) _SBOX32_CASE(80,hash,state,key) +#define case_80_SBOX32(hash,state,key) SBOX32_CASE_(80,hash,state,key) #else #define case_80_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 79 -#define case_79_SBOX32(hash,state,key) _SBOX32_CASE(79,hash,state,key) +#define case_79_SBOX32(hash,state,key) SBOX32_CASE_(79,hash,state,key) #else #define case_79_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 78 -#define case_78_SBOX32(hash,state,key) _SBOX32_CASE(78,hash,state,key) +#define case_78_SBOX32(hash,state,key) SBOX32_CASE_(78,hash,state,key) #else #define case_78_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 77 -#define case_77_SBOX32(hash,state,key) _SBOX32_CASE(77,hash,state,key) +#define case_77_SBOX32(hash,state,key) SBOX32_CASE_(77,hash,state,key) #else #define case_77_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 76 -#define case_76_SBOX32(hash,state,key) _SBOX32_CASE(76,hash,state,key) +#define case_76_SBOX32(hash,state,key) SBOX32_CASE_(76,hash,state,key) #else #define case_76_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 75 -#define case_75_SBOX32(hash,state,key) _SBOX32_CASE(75,hash,state,key) +#define case_75_SBOX32(hash,state,key) SBOX32_CASE_(75,hash,state,key) #else #define case_75_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 74 -#define case_74_SBOX32(hash,state,key) _SBOX32_CASE(74,hash,state,key) +#define case_74_SBOX32(hash,state,key) SBOX32_CASE_(74,hash,state,key) #else #define case_74_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 73 -#define case_73_SBOX32(hash,state,key) _SBOX32_CASE(73,hash,state,key) +#define case_73_SBOX32(hash,state,key) SBOX32_CASE_(73,hash,state,key) #else #define case_73_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 72 -#define case_72_SBOX32(hash,state,key) _SBOX32_CASE(72,hash,state,key) +#define case_72_SBOX32(hash,state,key) SBOX32_CASE_(72,hash,state,key) #else #define case_72_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 71 -#define case_71_SBOX32(hash,state,key) _SBOX32_CASE(71,hash,state,key) +#define case_71_SBOX32(hash,state,key) SBOX32_CASE_(71,hash,state,key) #else #define case_71_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 70 -#define case_70_SBOX32(hash,state,key) _SBOX32_CASE(70,hash,state,key) +#define case_70_SBOX32(hash,state,key) SBOX32_CASE_(70,hash,state,key) #else #define case_70_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 69 -#define case_69_SBOX32(hash,state,key) _SBOX32_CASE(69,hash,state,key) +#define case_69_SBOX32(hash,state,key) SBOX32_CASE_(69,hash,state,key) #else #define case_69_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 68 -#define case_68_SBOX32(hash,state,key) _SBOX32_CASE(68,hash,state,key) +#define case_68_SBOX32(hash,state,key) SBOX32_CASE_(68,hash,state,key) #else #define case_68_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 67 -#define case_67_SBOX32(hash,state,key) _SBOX32_CASE(67,hash,state,key) +#define case_67_SBOX32(hash,state,key) SBOX32_CASE_(67,hash,state,key) #else #define case_67_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 66 -#define case_66_SBOX32(hash,state,key) _SBOX32_CASE(66,hash,state,key) +#define case_66_SBOX32(hash,state,key) SBOX32_CASE_(66,hash,state,key) #else #define case_66_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 65 -#define case_65_SBOX32(hash,state,key) _SBOX32_CASE(65,hash,state,key) +#define case_65_SBOX32(hash,state,key) SBOX32_CASE_(65,hash,state,key) #else #define case_65_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 64 -#define case_64_SBOX32(hash,state,key) _SBOX32_CASE(64,hash,state,key) +#define case_64_SBOX32(hash,state,key) SBOX32_CASE_(64,hash,state,key) #else #define case_64_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 63 -#define case_63_SBOX32(hash,state,key) _SBOX32_CASE(63,hash,state,key) +#define case_63_SBOX32(hash,state,key) SBOX32_CASE_(63,hash,state,key) #else #define case_63_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 62 -#define case_62_SBOX32(hash,state,key) _SBOX32_CASE(62,hash,state,key) +#define case_62_SBOX32(hash,state,key) SBOX32_CASE_(62,hash,state,key) #else #define case_62_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 61 -#define case_61_SBOX32(hash,state,key) _SBOX32_CASE(61,hash,state,key) +#define case_61_SBOX32(hash,state,key) SBOX32_CASE_(61,hash,state,key) #else #define case_61_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 60 -#define case_60_SBOX32(hash,state,key) _SBOX32_CASE(60,hash,state,key) +#define case_60_SBOX32(hash,state,key) SBOX32_CASE_(60,hash,state,key) #else #define case_60_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 59 -#define case_59_SBOX32(hash,state,key) _SBOX32_CASE(59,hash,state,key) +#define case_59_SBOX32(hash,state,key) SBOX32_CASE_(59,hash,state,key) #else #define case_59_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 58 -#define case_58_SBOX32(hash,state,key) _SBOX32_CASE(58,hash,state,key) +#define case_58_SBOX32(hash,state,key) SBOX32_CASE_(58,hash,state,key) #else #define case_58_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 57 -#define case_57_SBOX32(hash,state,key) _SBOX32_CASE(57,hash,state,key) +#define case_57_SBOX32(hash,state,key) SBOX32_CASE_(57,hash,state,key) #else #define case_57_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 56 -#define case_56_SBOX32(hash,state,key) _SBOX32_CASE(56,hash,state,key) +#define case_56_SBOX32(hash,state,key) SBOX32_CASE_(56,hash,state,key) #else #define case_56_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 55 -#define case_55_SBOX32(hash,state,key) _SBOX32_CASE(55,hash,state,key) +#define case_55_SBOX32(hash,state,key) SBOX32_CASE_(55,hash,state,key) #else #define case_55_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 54 -#define case_54_SBOX32(hash,state,key) _SBOX32_CASE(54,hash,state,key) +#define case_54_SBOX32(hash,state,key) SBOX32_CASE_(54,hash,state,key) #else #define case_54_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 53 -#define case_53_SBOX32(hash,state,key) _SBOX32_CASE(53,hash,state,key) +#define case_53_SBOX32(hash,state,key) SBOX32_CASE_(53,hash,state,key) #else #define case_53_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 52 -#define case_52_SBOX32(hash,state,key) _SBOX32_CASE(52,hash,state,key) +#define case_52_SBOX32(hash,state,key) SBOX32_CASE_(52,hash,state,key) #else #define case_52_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 51 -#define case_51_SBOX32(hash,state,key) _SBOX32_CASE(51,hash,state,key) +#define case_51_SBOX32(hash,state,key) SBOX32_CASE_(51,hash,state,key) #else #define case_51_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 50 -#define case_50_SBOX32(hash,state,key) _SBOX32_CASE(50,hash,state,key) +#define case_50_SBOX32(hash,state,key) SBOX32_CASE_(50,hash,state,key) #else #define case_50_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 49 -#define case_49_SBOX32(hash,state,key) _SBOX32_CASE(49,hash,state,key) +#define case_49_SBOX32(hash,state,key) SBOX32_CASE_(49,hash,state,key) #else #define case_49_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 48 -#define case_48_SBOX32(hash,state,key) _SBOX32_CASE(48,hash,state,key) +#define case_48_SBOX32(hash,state,key) SBOX32_CASE_(48,hash,state,key) #else #define case_48_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 47 -#define case_47_SBOX32(hash,state,key) _SBOX32_CASE(47,hash,state,key) +#define case_47_SBOX32(hash,state,key) SBOX32_CASE_(47,hash,state,key) #else #define case_47_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 46 -#define case_46_SBOX32(hash,state,key) _SBOX32_CASE(46,hash,state,key) +#define case_46_SBOX32(hash,state,key) SBOX32_CASE_(46,hash,state,key) #else #define case_46_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 45 -#define case_45_SBOX32(hash,state,key) _SBOX32_CASE(45,hash,state,key) +#define case_45_SBOX32(hash,state,key) SBOX32_CASE_(45,hash,state,key) #else #define case_45_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 44 -#define case_44_SBOX32(hash,state,key) _SBOX32_CASE(44,hash,state,key) +#define case_44_SBOX32(hash,state,key) SBOX32_CASE_(44,hash,state,key) #else #define case_44_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 43 -#define case_43_SBOX32(hash,state,key) _SBOX32_CASE(43,hash,state,key) +#define case_43_SBOX32(hash,state,key) SBOX32_CASE_(43,hash,state,key) #else #define case_43_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 42 -#define case_42_SBOX32(hash,state,key) _SBOX32_CASE(42,hash,state,key) +#define case_42_SBOX32(hash,state,key) SBOX32_CASE_(42,hash,state,key) #else #define case_42_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 41 -#define case_41_SBOX32(hash,state,key) _SBOX32_CASE(41,hash,state,key) +#define case_41_SBOX32(hash,state,key) SBOX32_CASE_(41,hash,state,key) #else #define case_41_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 40 -#define case_40_SBOX32(hash,state,key) _SBOX32_CASE(40,hash,state,key) +#define case_40_SBOX32(hash,state,key) SBOX32_CASE_(40,hash,state,key) #else #define case_40_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 39 -#define case_39_SBOX32(hash,state,key) _SBOX32_CASE(39,hash,state,key) +#define case_39_SBOX32(hash,state,key) SBOX32_CASE_(39,hash,state,key) #else #define case_39_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 38 -#define case_38_SBOX32(hash,state,key) _SBOX32_CASE(38,hash,state,key) +#define case_38_SBOX32(hash,state,key) SBOX32_CASE_(38,hash,state,key) #else #define case_38_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 37 -#define case_37_SBOX32(hash,state,key) _SBOX32_CASE(37,hash,state,key) +#define case_37_SBOX32(hash,state,key) SBOX32_CASE_(37,hash,state,key) #else #define case_37_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 36 -#define case_36_SBOX32(hash,state,key) _SBOX32_CASE(36,hash,state,key) +#define case_36_SBOX32(hash,state,key) SBOX32_CASE_(36,hash,state,key) #else #define case_36_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 35 -#define case_35_SBOX32(hash,state,key) _SBOX32_CASE(35,hash,state,key) +#define case_35_SBOX32(hash,state,key) SBOX32_CASE_(35,hash,state,key) #else #define case_35_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 34 -#define case_34_SBOX32(hash,state,key) _SBOX32_CASE(34,hash,state,key) +#define case_34_SBOX32(hash,state,key) SBOX32_CASE_(34,hash,state,key) #else #define case_34_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 33 -#define case_33_SBOX32(hash,state,key) _SBOX32_CASE(33,hash,state,key) +#define case_33_SBOX32(hash,state,key) SBOX32_CASE_(33,hash,state,key) #else #define case_33_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 32 -#define case_32_SBOX32(hash,state,key) _SBOX32_CASE(32,hash,state,key) +#define case_32_SBOX32(hash,state,key) SBOX32_CASE_(32,hash,state,key) #else #define case_32_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 31 -#define case_31_SBOX32(hash,state,key) _SBOX32_CASE(31,hash,state,key) +#define case_31_SBOX32(hash,state,key) SBOX32_CASE_(31,hash,state,key) #else #define case_31_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 30 -#define case_30_SBOX32(hash,state,key) _SBOX32_CASE(30,hash,state,key) +#define case_30_SBOX32(hash,state,key) SBOX32_CASE_(30,hash,state,key) #else #define case_30_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 29 -#define case_29_SBOX32(hash,state,key) _SBOX32_CASE(29,hash,state,key) +#define case_29_SBOX32(hash,state,key) SBOX32_CASE_(29,hash,state,key) #else #define case_29_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 28 -#define case_28_SBOX32(hash,state,key) _SBOX32_CASE(28,hash,state,key) +#define case_28_SBOX32(hash,state,key) SBOX32_CASE_(28,hash,state,key) #else #define case_28_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 27 -#define case_27_SBOX32(hash,state,key) _SBOX32_CASE(27,hash,state,key) +#define case_27_SBOX32(hash,state,key) SBOX32_CASE_(27,hash,state,key) #else #define case_27_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 26 -#define case_26_SBOX32(hash,state,key) _SBOX32_CASE(26,hash,state,key) +#define case_26_SBOX32(hash,state,key) SBOX32_CASE_(26,hash,state,key) #else #define case_26_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 25 -#define case_25_SBOX32(hash,state,key) _SBOX32_CASE(25,hash,state,key) +#define case_25_SBOX32(hash,state,key) SBOX32_CASE_(25,hash,state,key) #else #define case_25_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 24 -#define case_24_SBOX32(hash,state,key) _SBOX32_CASE(24,hash,state,key) +#define case_24_SBOX32(hash,state,key) SBOX32_CASE_(24,hash,state,key) #else #define case_24_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 23 -#define case_23_SBOX32(hash,state,key) _SBOX32_CASE(23,hash,state,key) +#define case_23_SBOX32(hash,state,key) SBOX32_CASE_(23,hash,state,key) #else #define case_23_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 22 -#define case_22_SBOX32(hash,state,key) _SBOX32_CASE(22,hash,state,key) +#define case_22_SBOX32(hash,state,key) SBOX32_CASE_(22,hash,state,key) #else #define case_22_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 21 -#define case_21_SBOX32(hash,state,key) _SBOX32_CASE(21,hash,state,key) +#define case_21_SBOX32(hash,state,key) SBOX32_CASE_(21,hash,state,key) #else #define case_21_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 20 -#define case_20_SBOX32(hash,state,key) _SBOX32_CASE(20,hash,state,key) +#define case_20_SBOX32(hash,state,key) SBOX32_CASE_(20,hash,state,key) #else #define case_20_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 19 -#define case_19_SBOX32(hash,state,key) _SBOX32_CASE(19,hash,state,key) +#define case_19_SBOX32(hash,state,key) SBOX32_CASE_(19,hash,state,key) #else #define case_19_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 18 -#define case_18_SBOX32(hash,state,key) _SBOX32_CASE(18,hash,state,key) +#define case_18_SBOX32(hash,state,key) SBOX32_CASE_(18,hash,state,key) #else #define case_18_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 17 -#define case_17_SBOX32(hash,state,key) _SBOX32_CASE(17,hash,state,key) +#define case_17_SBOX32(hash,state,key) SBOX32_CASE_(17,hash,state,key) #else #define case_17_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 16 -#define case_16_SBOX32(hash,state,key) _SBOX32_CASE(16,hash,state,key) +#define case_16_SBOX32(hash,state,key) SBOX32_CASE_(16,hash,state,key) #else #define case_16_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 15 -#define case_15_SBOX32(hash,state,key) _SBOX32_CASE(15,hash,state,key) +#define case_15_SBOX32(hash,state,key) SBOX32_CASE_(15,hash,state,key) #else #define case_15_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 14 -#define case_14_SBOX32(hash,state,key) _SBOX32_CASE(14,hash,state,key) +#define case_14_SBOX32(hash,state,key) SBOX32_CASE_(14,hash,state,key) #else #define case_14_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 13 -#define case_13_SBOX32(hash,state,key) _SBOX32_CASE(13,hash,state,key) +#define case_13_SBOX32(hash,state,key) SBOX32_CASE_(13,hash,state,key) #else #define case_13_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 12 -#define case_12_SBOX32(hash,state,key) _SBOX32_CASE(12,hash,state,key) +#define case_12_SBOX32(hash,state,key) SBOX32_CASE_(12,hash,state,key) #else #define case_12_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 11 -#define case_11_SBOX32(hash,state,key) _SBOX32_CASE(11,hash,state,key) +#define case_11_SBOX32(hash,state,key) SBOX32_CASE_(11,hash,state,key) #else #define case_11_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 10 -#define case_10_SBOX32(hash,state,key) _SBOX32_CASE(10,hash,state,key) +#define case_10_SBOX32(hash,state,key) SBOX32_CASE_(10,hash,state,key) #else #define case_10_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 9 -#define case_9_SBOX32(hash,state,key) _SBOX32_CASE(9,hash,state,key) +#define case_9_SBOX32(hash,state,key) SBOX32_CASE_(9,hash,state,key) #else #define case_9_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 8 -#define case_8_SBOX32(hash,state,key) _SBOX32_CASE(8,hash,state,key) +#define case_8_SBOX32(hash,state,key) SBOX32_CASE_(8,hash,state,key) #else #define case_8_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 7 -#define case_7_SBOX32(hash,state,key) _SBOX32_CASE(7,hash,state,key) +#define case_7_SBOX32(hash,state,key) SBOX32_CASE_(7,hash,state,key) #else #define case_7_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 6 -#define case_6_SBOX32(hash,state,key) _SBOX32_CASE(6,hash,state,key) +#define case_6_SBOX32(hash,state,key) SBOX32_CASE_(6,hash,state,key) #else #define case_6_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 5 -#define case_5_SBOX32(hash,state,key) _SBOX32_CASE(5,hash,state,key) +#define case_5_SBOX32(hash,state,key) SBOX32_CASE_(5,hash,state,key) #else #define case_5_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 4 -#define case_4_SBOX32(hash,state,key) _SBOX32_CASE(4,hash,state,key) +#define case_4_SBOX32(hash,state,key) SBOX32_CASE_(4,hash,state,key) #else #define case_4_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 3 -#define case_3_SBOX32(hash,state,key) _SBOX32_CASE(3,hash,state,key) +#define case_3_SBOX32(hash,state,key) SBOX32_CASE_(3,hash,state,key) #else #define case_3_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 2 -#define case_2_SBOX32(hash,state,key) _SBOX32_CASE(2,hash,state,key) +#define case_2_SBOX32(hash,state,key) SBOX32_CASE_(2,hash,state,key) #else #define case_2_SBOX32(hash,state,key) /**/ #endif #if SBOX32_MAX_LEN >= 1 -#define case_1_SBOX32(hash,state,key) _SBOX32_CASE(1,hash,state,key) +#define case_1_SBOX32(hash,state,key) SBOX32_CASE_(1,hash,state,key) #else #define case_1_SBOX32(hash,state,key) /**/ #endif @@ -1400,7 +1400,7 @@ #define SBOX32_CHURN_ROUNDS 128 #endif -#define _SBOX32_CASE(len,hash,state,key) \ +#define SBOX32_CASE_(len,hash,state,key) \ /* FALLTHROUGH */ \ case len: hash ^= state[ 1 + ( 256 * ( len - 1 ) ) + key[ len - 1 ] ]; From f6fcc0a888df918bd538b38d5df96d16f13c31cd Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:32:23 -0600 Subject: [PATCH 02/87] util.c: Convert _SV_LOG_SERIAL_ARG to legal name --- util.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/util.c b/util.c index ded6cf6e8cbc..2ee09edef6af 100644 --- a/util.c +++ b/util.c @@ -4959,10 +4959,10 @@ Perl_debug_hash_seed(pTHX_ bool via_debug_h) # ifdef DEBUG_LEAKING_SCALARS # define SV_LOG_SERIAL_FMT " [%lu]" -# define _SV_LOG_SERIAL_ARG(sv) , (unsigned long) (sv)->sv_debug_serial +# define SV_LOG_SERIAL_ARG_(sv) , (unsigned long) (sv)->sv_debug_serial # else # define SV_LOG_SERIAL_FMT -# define _SV_LOG_SERIAL_ARG(sv) +# define SV_LOG_SERIAL_ARG_(sv) # endif static void @@ -5049,7 +5049,7 @@ S_mem_log_common(enum mem_log_type mlt, const UV n, "%s_SV: %s:%d:%s: %" UVxf SV_LOG_SERIAL_FMT "\n", mlt == MLT_NEW_SV ? "new" : "del", filename, linenumber, funcname, - PTR2UV(sv) _SV_LOG_SERIAL_ARG(sv)); + PTR2UV(sv) SV_LOG_SERIAL_ARG_(sv)); break; default: len = 0; From 826df9c9615a8e30d2f543a714219eab7342c363 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:33:57 -0600 Subject: [PATCH 03/87] util.c: Convert _rand48_(mult|add) to legal names --- util.c | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/util.c b/util.c index 2ee09edef6af..6712433f35cf 100644 --- a/util.c +++ b/util.c @@ -5999,12 +5999,12 @@ Perl_get_re_arg(pTHX_ SV *sv) { #define FREEBSD_DRAND48_MULT_2 (0x0005) #define FREEBSD_DRAND48_ADD (0x000b) -const unsigned short _rand48_mult[3] = { +const unsigned short rand48_mult_[3] = { FREEBSD_DRAND48_MULT_0, FREEBSD_DRAND48_MULT_1, FREEBSD_DRAND48_MULT_2 }; -const unsigned short _rand48_add = FREEBSD_DRAND48_ADD; +const unsigned short rand48_add_ = FREEBSD_DRAND48_ADD; #endif @@ -6037,17 +6037,17 @@ Perl_drand48_r(perl_drand48_t *random_state) U32 accu; U16 temp[2]; - accu = (U32) _rand48_mult[0] * (U32) random_state->seed[0] - + (U32) _rand48_add; + accu = (U32) rand48_mult_[0] * (U32) random_state->seed[0] + + (U32) rand48_add_; temp[0] = (U16) accu; /* lower 16 bits */ accu >>= sizeof(U16) * 8; - accu += (U32) _rand48_mult[0] * (U32) random_state->seed[1] - + (U32) _rand48_mult[1] * (U32) random_state->seed[0]; + accu += (U32) rand48_mult_[0] * (U32) random_state->seed[1] + + (U32) rand48_mult_[1] * (U32) random_state->seed[0]; temp[1] = (U16) accu; /* middle 16 bits */ accu >>= sizeof(U16) * 8; - accu += _rand48_mult[0] * random_state->seed[2] - + _rand48_mult[1] * random_state->seed[1] - + _rand48_mult[2] * random_state->seed[0]; + accu += rand48_mult_[0] * random_state->seed[2] + + rand48_mult_[1] * random_state->seed[1] + + rand48_mult_[2] * random_state->seed[0]; random_state->seed[0] = temp[0]; random_state->seed[1] = temp[1]; random_state->seed[2] = (U16) accu; From 698c2ee3fbc4093dd3f7b9ac8f9c9e1cd6ec0eb2 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:37:39 -0600 Subject: [PATCH 04/87] pad.h: Convert _PADNAME_BASE to legal name --- pad.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/pad.h b/pad.h index 0877aa6c3124..2f0cbe3f1e64 100644 --- a/pad.h +++ b/pad.h @@ -57,7 +57,7 @@ struct padnamelist { struct padname_fieldinfo; -#define _PADNAME_BASE \ +#define PADNAME_BASE_ \ char * xpadn_pv; \ HV * xpadn_ourstash; \ union { \ @@ -73,19 +73,19 @@ struct padname_fieldinfo; U8 xpadn_flags struct padname { - _PADNAME_BASE; + PADNAME_BASE_; }; struct padname_with_str { #ifdef PERL_PADNAME_MINIMAL - _PADNAME_BASE; + PADNAME_BASE_; #else struct padname xpadn_padname; #endif char xpadn_str[1]; }; -#undef _PADNAME_BASE +#undef PADNAME_BASE_ #define PADNAME_FROM_PV(s) \ ((PADNAME *)((s) - STRUCT_OFFSET(struct padname_with_str, xpadn_str))) From 9c726a7c12f17a40c259064d239d6aff5ede5041 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:39:13 -0600 Subject: [PATCH 05/87] pp.h: Convert _EXTEND_SAFE_N to legal name --- pp.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pp.h b/pp.h index 76d29202b227..21ed3b8fbb42 100644 --- a/pp.h +++ b/pp.h @@ -397,27 +397,27 @@ Does not use C. See also C>, C> and C>. # define EXTEND_HWM_SET(p, n) NOOP #endif -/* _EXTEND_SAFE_N(n): private helper macro for EXTEND(). +/* EXTEND_SAFE_N_(n): private helper macro for EXTEND(). * Tests whether the value of n would be truncated when implicitly cast to * SSize_t as an arg to stack_grow(). If so, sets it to -1 instead to * trigger a panic. It will be constant folded on platforms where this * can't happen. */ -#define _EXTEND_SAFE_N(n) \ +#define EXTEND_SAFE_N_(n) \ (sizeof(n) > sizeof(SSize_t) && ((SSize_t)(n) != (n)) ? -1 : (n)) #ifdef STRESS_REALLOC # define EXTEND_SKIP(p, n) EXTEND_HWM_SET(p, n) # define EXTEND(p,n) STMT_START { \ - sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \ + sp = stack_grow(sp,p,EXTEND_SAFE_N_(n)); \ PERL_UNUSED_VAR(sp); \ } STMT_END /* Same thing, but update mark register too. */ # define MEXTEND(p,n) STMT_START { \ const SSize_t markoff = mark - PL_stack_base; \ - sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \ + sp = stack_grow(sp,p,EXTEND_SAFE_N_(n)); \ mark = PL_stack_base + markoff; \ PERL_UNUSED_VAR(sp); \ } STMT_END @@ -459,7 +459,7 @@ Does not use C. See also C>, C> and C>. # define EXTEND(p,n) STMT_START { \ EXTEND_HWM_SET(p, n); \ if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) { \ - sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \ + sp = stack_grow(sp,p,EXTEND_SAFE_N_(n)); \ PERL_UNUSED_VAR(sp); \ } \ } STMT_END @@ -468,7 +468,7 @@ Does not use C. See also C>, C> and C>. EXTEND_HWM_SET(p, n); \ if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) { \ const SSize_t markoff = mark - PL_stack_base;\ - sp = stack_grow(sp,p,_EXTEND_SAFE_N(n)); \ + sp = stack_grow(sp,p,EXTEND_SAFE_N_(n)); \ mark = PL_stack_base + markoff; \ PERL_UNUSED_VAR(sp); \ } \ From d3db40349138d1498741ad6199d0f0c7940c75cd Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:41:51 -0600 Subject: [PATCH 06/87] pp.h: Convert _EXTEND_NEEDS_GROW to legal name --- inline.h | 2 +- pp.h | 10 +++++----- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/inline.h b/inline.h index 659e0dba88ef..0c952c582f6a 100644 --- a/inline.h +++ b/inline.h @@ -407,7 +407,7 @@ Perl_rpp_extend(pTHX_ SSize_t n) EXTEND_HWM_SET(PL_stack_sp, n); #ifndef STRESS_REALLOC - if (UNLIKELY(_EXTEND_NEEDS_GROW(PL_stack_sp, n))) + if (UNLIKELY(EXTEND_NEEDS_GROW_(PL_stack_sp, n))) #endif { (void)stack_grow(PL_stack_sp, PL_stack_sp, n); diff --git a/pp.h b/pp.h index 21ed3b8fbb42..c06817ddef17 100644 --- a/pp.h +++ b/pp.h @@ -423,7 +423,7 @@ Does not use C. See also C>, C> and C>. } STMT_END #else -/* _EXTEND_NEEDS_GROW(p,n): private helper macro for EXTEND(). +/* EXTEND_NEEDS_GROW_(p,n): private helper macro for EXTEND(). * Tests to see whether n is too big and we need to grow the stack. Be * very careful if modifying this. There are many ways to get things wrong * (wrapping, truncating etc) that could cause a false negative and cause @@ -439,7 +439,7 @@ Does not use C. See also C>, C> and C>. * this just gives a safe false positive */ -# define _EXTEND_NEEDS_GROW(p,n) ((n) < 0 || PL_stack_max - (p) < (n)) +# define EXTEND_NEEDS_GROW_(p,n) ((n) < 0 || PL_stack_max - (p) < (n)) /* EXTEND_SKIP(): used for where you would normally call EXTEND(), but @@ -452,13 +452,13 @@ Does not use C. See also C>, C> and C>. # define EXTEND_SKIP(p, n) STMT_START { \ EXTEND_HWM_SET(p, n); \ - assert(!_EXTEND_NEEDS_GROW(p,n)); \ + assert(!EXTEND_NEEDS_GROW_(p,n)); \ } STMT_END # define EXTEND(p,n) STMT_START { \ EXTEND_HWM_SET(p, n); \ - if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) { \ + if (UNLIKELY(EXTEND_NEEDS_GROW_(p,n))) { \ sp = stack_grow(sp,p,EXTEND_SAFE_N_(n)); \ PERL_UNUSED_VAR(sp); \ } \ @@ -466,7 +466,7 @@ Does not use C. See also C>, C> and C>. /* Same thing, but update mark register too. */ # define MEXTEND(p,n) STMT_START { \ EXTEND_HWM_SET(p, n); \ - if (UNLIKELY(_EXTEND_NEEDS_GROW(p,n))) { \ + if (UNLIKELY(EXTEND_NEEDS_GROW_(p,n))) { \ const SSize_t markoff = mark - PL_stack_base;\ sp = stack_grow(sp,p,EXTEND_SAFE_N_(n)); \ mark = PL_stack_base + markoff; \ From 61704204e33eaf97ae279d52273feecbd16eeb5f Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:43:12 -0600 Subject: [PATCH 07/87] pack.c: Convert _action to legal name --- pp_pack.c | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/pp_pack.c b/pp_pack.c index 5b09d78000b9..f210984f4e37 100644 --- a/pp_pack.c +++ b/pp_pack.c @@ -449,7 +449,7 @@ STMT_START { \ str += retlen; \ } STMT_END -static const char *_action( const tempsym_t* symptr ) +static const char *action_( const tempsym_t* symptr ) { return (const char *)(( symptr->flags & FLAG_PACK ) ? "pack" : "unpack"); } @@ -468,7 +468,7 @@ S_measure_struct(pTHX_ tempsym_t* symptr) switch (symptr->howlen) { case e_star: croak("Within []-length '*' not allowed in %s", - _action( symptr ) ); + action_( symptr ) ); default: /* e_no_len and e_number */ @@ -485,7 +485,7 @@ S_measure_struct(pTHX_ tempsym_t* symptr) /* diag_listed_as: Invalid type '%s' in %s */ croak("Invalid type '%c' in %s", (int)TYPE_NO_MODIFIERS(symptr->code), - _action( symptr ) ); + action_( symptr ) ); case '.' | TYPE_IS_SHRIEKING: case '@' | TYPE_IS_SHRIEKING: case '@': @@ -496,7 +496,7 @@ S_measure_struct(pTHX_ tempsym_t* symptr) case 'u': croak("Within []-length '%c' not allowed in %s", (int) TYPE_NO_MODIFIERS(symptr->code), - _action( symptr ) ); + action_( symptr ) ); case '%': size = 0; break; @@ -523,7 +523,7 @@ S_measure_struct(pTHX_ tempsym_t* symptr) case 'X': size = -1; if (total < len) - croak("'X' outside of string in %s", _action( symptr ) ); + croak("'X' outside of string in %s", action_( symptr ) ); break; case 'x' | TYPE_IS_SHRIEKING: if (!len) /* Avoid division by 0 */ @@ -650,7 +650,7 @@ S_next_symbol(pTHX_ tempsym_t* symptr ) symptr->flags |= FLAG_COMMA; /* diag_listed_as: Invalid type '%s' in %s */ warner(packWARN(WARN_UNPACK), - "Invalid type ',' in %s", _action( symptr ) ); + "Invalid type ',' in %s", action_( symptr ) ); } continue; } @@ -659,12 +659,12 @@ S_next_symbol(pTHX_ tempsym_t* symptr ) if (code == '(') { if( isDIGIT(*patptr) || *patptr == '*' || *patptr == '[' ) croak("()-group starts with a count in %s", - _action( symptr ) ); + action_( symptr ) ); symptr->grpbeg = patptr; patptr = 1 + ( symptr->grpend = group_end(patptr, patend, ')') ); if( symptr->level >= MAX_SUB_TEMPLATE_LEVEL ) croak("Too deeply nested ()-groups in %s", - _action( symptr ) ); + action_( symptr ) ); } /* look for group modifiers to inherit */ @@ -701,21 +701,21 @@ S_next_symbol(pTHX_ tempsym_t* symptr ) if (!strchr(allowed, TYPE_NO_MODIFIERS(code))) croak("'%c' allowed only after types %s in %s", *patptr, - allowed, _action( symptr ) ); + allowed, action_( symptr ) ); if (TYPE_ENDIANNESS(code | modifier) == TYPE_ENDIANNESS_MASK) croak("Can't use both '<' and '>' after type '%c' in %s", - (int) TYPE_NO_MODIFIERS(code), _action( symptr ) ); + (int) TYPE_NO_MODIFIERS(code), action_( symptr ) ); else if (TYPE_ENDIANNESS(code | modifier | inherited_modifiers) == TYPE_ENDIANNESS_MASK) croak("Can't use '%c' in a group with different byte-order in %s", - *patptr, _action( symptr ) ); + *patptr, action_( symptr ) ); if ((code & modifier)) { ck_warner(packWARN(WARN_UNPACK), "Duplicate modifier '%c' after '%c' in %s", *patptr, (int) TYPE_NO_MODIFIERS(code), - _action( symptr ) ); + action_( symptr ) ); } code |= modifier; @@ -744,7 +744,7 @@ S_next_symbol(pTHX_ tempsym_t* symptr ) lenptr = get_num( lenptr, &symptr->length ); if( *lenptr != ']' ) croak("Malformed integer in [] in %s", - _action( symptr ) ); + action_( symptr ) ); } else { tempsym_t savsym = *symptr; symptr->patend = patptr-1; @@ -774,7 +774,7 @@ S_next_symbol(pTHX_ tempsym_t* symptr ) if (patptr < patend && (isDIGIT(*patptr) || *patptr == '*' || *patptr == '[')) croak("'/' does not take a repeat count in %s", - _action( symptr ) ); + action_( symptr ) ); } break; } From de709d5cd2da3a93695a5e79676304db0ff8e22b Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:01:05 -0600 Subject: [PATCH 08/87] class.c. Convert _arg to legal name --- class.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/class.c b/class.c index 9b27be6f2d9a..f731b986dc00 100644 --- a/class.c +++ b/class.c @@ -345,9 +345,9 @@ PP(pp_methstart) } static void -invoke_class_seal(pTHX_ void *_arg) +invoke_class_seal(pTHX_ void *arg_) { - class_seal_stash((HV *)_arg); + class_seal_stash((HV *)arg_); } void From 65a09b5821e62109df91a83ba1f3c532e7db7d97 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:02:20 -0600 Subject: [PATCH 09/87] class.c. Convert _nOnclAshIngNamE_ to legal name --- cop.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/cop.h b/cop.h index a1d1ffba3c5e..7ff31fec18f5 100644 --- a/cop.h +++ b/cop.h @@ -1398,8 +1398,8 @@ See L. #define PUSH_MULTICALL_FLAGS(the_cv, flags) \ STMT_START { \ PERL_CONTEXT *cx; \ - CV * const _nOnclAshIngNamE_ = the_cv; \ - CV * const cv = _nOnclAshIngNamE_; \ + CV * const nOnclAshIngNamE_ = the_cv; \ + CV * const cv = nOnclAshIngNamE_; \ PADLIST * const padlist = CvPADLIST(cv); \ multicall_oldcatch = CATCH_GET; \ CATCH_SET(TRUE); \ @@ -1442,8 +1442,8 @@ See L. #define CHANGE_MULTICALL_FLAGS(the_cv, flags) \ STMT_START { \ - CV * const _nOnclAshIngNamE_ = the_cv; \ - CV * const cv = _nOnclAshIngNamE_; \ + CV * const nOnclAshIngNamE_ = the_cv; \ + CV * const cv = nOnclAshIngNamE_; \ PADLIST * const padlist = CvPADLIST(cv); \ PERL_CONTEXT *cx = CX_CUR(); \ assert(CxMULTICALL(cx)); \ From 735f77b838e94a979a5d353488eaf0cfd74f11c9 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:04:12 -0600 Subject: [PATCH 10/87] hv_macro.h. Convert _shifted_octet to legal name --- hv_macro.h | 30 +++++++++++++++--------------- 1 file changed, 15 insertions(+), 15 deletions(-) diff --git a/hv_macro.h b/hv_macro.h index 5bf02a80ed2d..eba62131edd0 100644 --- a/hv_macro.h +++ b/hv_macro.h @@ -30,28 +30,28 @@ */ #ifndef U8TO16_LE - #define _shifted_octet(type,ptr,idx,shift) (((type)(((const U8*)(ptr))[(idx)]))<<(shift)) + #define shifted_octet_(type,ptr,idx,shift) (((type)(((const U8*)(ptr))[(idx)]))<<(shift)) #if defined(USE_UNALIGNED_PTR_DEREF) && (BYTEORDER == 0x1234 || BYTEORDER == 0x12345678) #define U8TO16_LE(ptr) (*((const U16*)(ptr))) #define U8TO32_LE(ptr) (*((const U32*)(ptr))) #define U8TO64_LE(ptr) (*((const U64*)(ptr))) #else - #define U8TO16_LE(ptr) (_shifted_octet(U16,(ptr),0, 0)|\ - _shifted_octet(U16,(ptr),1, 8)) + #define U8TO16_LE(ptr) (shifted_octet_(U16,(ptr),0, 0)|\ + shifted_octet_(U16,(ptr),1, 8)) - #define U8TO32_LE(ptr) (_shifted_octet(U32,(ptr),0, 0)|\ - _shifted_octet(U32,(ptr),1, 8)|\ - _shifted_octet(U32,(ptr),2,16)|\ - _shifted_octet(U32,(ptr),3,24)) + #define U8TO32_LE(ptr) (shifted_octet_(U32,(ptr),0, 0)|\ + shifted_octet_(U32,(ptr),1, 8)|\ + shifted_octet_(U32,(ptr),2,16)|\ + shifted_octet_(U32,(ptr),3,24)) - #define U8TO64_LE(ptr) (_shifted_octet(U64,(ptr),0, 0)|\ - _shifted_octet(U64,(ptr),1, 8)|\ - _shifted_octet(U64,(ptr),2,16)|\ - _shifted_octet(U64,(ptr),3,24)|\ - _shifted_octet(U64,(ptr),4,32)|\ - _shifted_octet(U64,(ptr),5,40)|\ - _shifted_octet(U64,(ptr),6,48)|\ - _shifted_octet(U64,(ptr),7,56)) + #define U8TO64_LE(ptr) (shifted_octet_(U64,(ptr),0, 0)|\ + shifted_octet_(U64,(ptr),1, 8)|\ + shifted_octet_(U64,(ptr),2,16)|\ + shifted_octet_(U64,(ptr),3,24)|\ + shifted_octet_(U64,(ptr),4,32)|\ + shifted_octet_(U64,(ptr),5,40)|\ + shifted_octet_(U64,(ptr),6,48)|\ + shifted_octet_(U64,(ptr),7,56)) #endif #endif From 1b40691b97a530638f68c8f4f3eb3a880d8c4c3f Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:10:14 -0600 Subject: [PATCH 11/87] hv_macro.h. Convert _dv to legal name --- sv.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sv.c b/sv.c index 205a8772eb7b..dcb0e8f7bc84 100644 --- a/sv.c +++ b/sv.c @@ -12025,8 +12025,8 @@ Perl_sv_vcatpvfn(pTHX_ SV *const sv, const char *const pat, const STRLEN patlen, /* Work around breakage in OTS$CVT_FLOAT_T_X */ # define VCATPVFN_NV_TO_FV(nv,fv) \ STMT_START { \ - double _dv = nv; \ - fv = Perl_isnan(_dv) ? LDBL_QNAN : _dv; \ + double dv_ = nv; \ + fv = Perl_isnan(_dv) ? LDBL_QNAN : dv_; \ } STMT_END # else # define VCATPVFN_NV_TO_FV(nv,fv) (fv)=(nv) From 35c1b61102e4677662b9cd8bc67615cb018a7551 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:44:32 -0600 Subject: [PATCH 12/87] regcomp_internal.h. Convert _FAIL to legal name --- regcomp_internal.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/regcomp_internal.h b/regcomp_internal.h index 28babe4d0bf0..400a3568b58d 100644 --- a/regcomp_internal.h +++ b/regcomp_internal.h @@ -875,7 +875,7 @@ static const scan_data_t zero_scan_data = { * arg. Show regex, up to a maximum length. If it's too long, chop and add * "...". */ -#define _FAIL(code) STMT_START { \ +#define FAIL_(code) STMT_START { \ const char *ellipses = ""; \ IV len = RExC_precomp_end - RExC_precomp; \ \ @@ -887,15 +887,15 @@ static const scan_data_t zero_scan_data = { code; \ } STMT_END -#define FAIL(msg) _FAIL( \ +#define FAIL(msg) FAIL_( \ croak("%s in regex m/%" UTF8f "%s/", \ msg, UTF8fARG(UTF, len, RExC_precomp), ellipses)) -#define FAIL2(msg,arg) _FAIL( \ +#define FAIL2(msg,arg) FAIL_( \ croak(msg " in regex m/%" UTF8f "%s/", \ arg, UTF8fARG(UTF, len, RExC_precomp), ellipses)) -#define FAIL3(msg,arg1,arg2) _FAIL( \ +#define FAIL3(msg,arg1,arg2) FAIL_( \ croak(msg " in regex m/%" UTF8f "%s/", \ arg1, arg2, UTF8fARG(UTF, len, RExC_precomp), ellipses)) From 4b821d1ac72dd5efa68bf137b4dc8e6b3c24e28b Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:45:03 -0600 Subject: [PATCH 13/87] regcomp_internal.h. Convert _WARN_HELPER to legal name --- regcomp_internal.h | 34 +++++++++++++++++----------------- regcomp_study.c | 2 +- 2 files changed, 18 insertions(+), 18 deletions(-) diff --git a/regcomp_internal.h b/regcomp_internal.h index 400a3568b58d..e4dc8636c5be 100644 --- a/regcomp_internal.h +++ b/regcomp_internal.h @@ -962,7 +962,7 @@ static const scan_data_t zero_scan_data = { } STMT_END /* 'warns' is the output of the packWARNx macro used in 'code' */ -#define _WARN_HELPER(loc, warns, code) \ +#define WARN_HELPER_(loc, warns, code) \ STMT_START { \ if (! RExC_copy_start_in_constructed) { \ croak("panic! %s: %d: Tried to warn when none" \ @@ -977,7 +977,7 @@ static const scan_data_t zero_scan_data = { /* m is not necessarily a "literal string", in this macro */ #define warn_non_literal_string(loc, packed_warn, m) \ - _WARN_HELPER(loc, packed_warn, \ + WARN_HELPER_(loc, packed_warn, \ Perl_warner(aTHX_ packed_warn, \ "%s" REPORT_LOCATION, \ m, REPORT_LOCATION_ARGS(loc))) @@ -992,84 +992,84 @@ static const scan_data_t zero_scan_data = { my_strlcpy(format, m, format_size); \ my_strlcat(format, REPORT_LOCATION, format_size); \ SAVEFREEPV(format); \ - _WARN_HELPER(loc, packwarn, \ + WARN_HELPER_(loc, packwarn, \ Perl_ck_warner(aTHX_ packwarn, \ format, \ a1, REPORT_LOCATION_ARGS(loc))); \ } STMT_END #define ckWARNreg(loc,m) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ REPORT_LOCATION_ARGS(loc))) #define vWARN(loc, m) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ REPORT_LOCATION_ARGS(loc))) \ #define vWARN_dep(loc,category,m) \ - _WARN_HELPER(loc, packWARN(category), \ + WARN_HELPER_(loc, packWARN(category), \ Perl_warner(aTHX_ packWARN(category), \ m REPORT_LOCATION, \ REPORT_LOCATION_ARGS(loc))) #define ckWARNdep(loc,category,m) \ - _WARN_HELPER(loc, packWARN(category), \ + WARN_HELPER_(loc, packWARN(category), \ Perl_ck_warner_d(aTHX_ packWARN(category), \ m REPORT_LOCATION, \ REPORT_LOCATION_ARGS(loc))) #define ckWARNregdep(loc,category,m) \ - _WARN_HELPER(loc, packWARN2(category, WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN2(category, WARN_REGEXP), \ Perl_ck_warner_d(aTHX_ packWARN2(category, \ WARN_REGEXP), \ m REPORT_LOCATION, \ REPORT_LOCATION_ARGS(loc))) #define ckWARN2reg_d(loc,m, a1) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_ck_warner_d(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ a1, REPORT_LOCATION_ARGS(loc))) #define ckWARN2reg(loc, m, a1) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ a1, REPORT_LOCATION_ARGS(loc))) #define vWARN3(loc, m, a1, a2) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ a1, a2, REPORT_LOCATION_ARGS(loc))) #define ckWARN3reg(loc, m, a1, a2) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ a1, a2, \ REPORT_LOCATION_ARGS(loc))) #define vWARN4(loc, m, a1, a2, a3) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ a1, a2, a3, \ REPORT_LOCATION_ARGS(loc))) #define ckWARN4reg(loc, m, a1, a2, a3) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ a1, a2, a3, \ REPORT_LOCATION_ARGS(loc))) #define vWARN5(loc, m, a1, a2, a3, a4) \ - _WARN_HELPER(loc, packWARN(WARN_REGEXP), \ + WARN_HELPER_(loc, packWARN(WARN_REGEXP), \ Perl_warner(aTHX_ packWARN(WARN_REGEXP), \ m REPORT_LOCATION, \ a1, a2, a3, a4, \ @@ -1079,7 +1079,7 @@ static const scan_data_t zero_scan_data = { STMT_START { \ if (! RExC_warned_ ## class) { /* warn once per compilation */ \ RExC_warned_ ## class = 1; \ - _WARN_HELPER(loc, packWARN(class), \ + WARN_HELPER_(loc, packWARN(class), \ Perl_ck_warner_d(aTHX_ packWARN(class), \ m REPORT_LOCATION, \ REPORT_LOCATION_ARGS(loc)));\ @@ -1090,7 +1090,7 @@ static const scan_data_t zero_scan_data = { STMT_START { \ if (! RExC_warned_ ## class) { /* warn once per compilation */ \ RExC_warned_ ## class = 1; \ - _WARN_HELPER(loc, packWARN(class), \ + WARN_HELPER_(loc, packWARN(class), \ Perl_ck_warner_d(aTHX_ packWARN(class), \ m REPORT_LOCATION, \ arg, REPORT_LOCATION_ARGS(loc)));\ diff --git a/regcomp_study.c b/regcomp_study.c index 7d4a395844c0..7c6301707f8c 100644 --- a/regcomp_study.c +++ b/regcomp_study.c @@ -2562,7 +2562,7 @@ Perl_study_chunk(pTHX_ && maxcount <= REG_INFTY/3) /* Complement check for big count */ { - _WARN_HELPER(RExC_precomp_end, packWARN(WARN_REGEXP), + WARN_HELPER_(RExC_precomp_end, packWARN(WARN_REGEXP), Perl_ck_warner(aTHX_ packWARN(WARN_REGEXP), "Quantifier unexpected on zero-length expression " "in regex m/%" UTF8f "/", From db932171e28f4dbc74e4dee9f4d94c03a580508f Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:48:59 -0600 Subject: [PATCH 14/87] regexec.c. Convert _generic_GET_BREAK_VAL_CP_CHECKED to legal name --- regexec.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/regexec.c b/regexec.c index d92f33c89ace..446a8cf7cfd5 100644 --- a/regexec.c +++ b/regexec.c @@ -2192,10 +2192,10 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { assert(cp_out >= 0); return cp_out; } -# define _generic_GET_BREAK_VAL_CP_CHECKED(invlist, invmap, cp) \ +# define generic_GET_BREAK_VAL_CP_CHECKED_(invlist, invmap, cp) \ invmap[S_get_break_val_cp_checked(invlist, cp)] #else -# define _generic_GET_BREAK_VAL_CP_CHECKED(invlist, invmap, cp) \ +# define generic_GET_BREAK_VAL_CP_CHECKED_(invlist, invmap, cp) \ invmap[_invlist_search(invlist, cp)] #endif @@ -2204,7 +2204,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { * according to the two arrays. It assumes that all code points have a value. * This is used as the base macro for macros for particular properties */ #define _generic_GET_BREAK_VAL_CP(invlist, invmap, cp) \ - _generic_GET_BREAK_VAL_CP_CHECKED(invlist, invmap, cp) + generic_GET_BREAK_VAL_CP_CHECKED_(invlist, invmap, cp) /* Same as above, but takes begin, end ptrs to a UTF-8 encoded string instead * of a code point, returning the value for the first code point in the string. From 690636cfbe18cc0b28a8f2d2b991ba7d98d7fd44 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:54:16 -0600 Subject: [PATCH 15/87] regexec.c. Convert _generic_GET_BREAK_VAL_CP_ to legal name --- regexec.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/regexec.c b/regexec.c index 446a8cf7cfd5..e0922262bb2b 100644 --- a/regexec.c +++ b/regexec.c @@ -2203,7 +2203,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { * inversion map, and a code point, and returns the code point's value * according to the two arrays. It assumes that all code points have a value. * This is used as the base macro for macros for particular properties */ -#define _generic_GET_BREAK_VAL_CP(invlist, invmap, cp) \ +#define generic_GET_BREAK_VAL_CP_(invlist, invmap, cp) \ generic_GET_BREAK_VAL_CP_CHECKED_(invlist, invmap, cp) /* Same as above, but takes begin, end ptrs to a UTF-8 encoded string instead @@ -2217,7 +2217,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { /* Returns the GCB value for the input code point */ #define getGCB_VAL_CP(cp) \ - _generic_GET_BREAK_VAL_CP( \ + generic_GET_BREAK_VAL_CP_( \ PL_GCB_invlist, \ _Perl_GCB_invmap, \ (cp)) @@ -2229,7 +2229,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { /* Returns the LB value for the input code point */ #define getLB_VAL_CP(cp) \ - _generic_GET_BREAK_VAL_CP( \ + generic_GET_BREAK_VAL_CP_( \ PL_LB_invlist, \ _Perl_LB_invmap, \ (cp)) @@ -2242,7 +2242,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { /* Returns the SB value for the input code point */ #define getSB_VAL_CP(cp) \ - _generic_GET_BREAK_VAL_CP( \ + generic_GET_BREAK_VAL_CP_( \ PL_SB_invlist, \ _Perl_SB_invmap, \ (cp)) @@ -2254,7 +2254,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { /* Returns the WB value for the input code point */ #define getWB_VAL_CP(cp) \ - _generic_GET_BREAK_VAL_CP( \ + generic_GET_BREAK_VAL_CP_( \ PL_WB_invlist, \ _Perl_WB_invmap, \ (cp)) From 6ef454f7611fb8f54b10420da5ed1821ed436fe6 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:54:51 -0600 Subject: [PATCH 16/87] regexec.c. Convert _generic_GET_BREAK_VAL_UTF8_ to legal name --- regexec.c | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/regexec.c b/regexec.c index e0922262bb2b..3eb8fe3a57cd 100644 --- a/regexec.c +++ b/regexec.c @@ -2210,7 +2210,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { * of a code point, returning the value for the first code point in the string. * And it takes the particular macro name that finds the desired value given a * code point. Merely convert the UTF-8 to code point and call the cp macro */ -#define _generic_GET_BREAK_VAL_UTF8(cp_macro, pos, strend) \ +#define generic_GET_BREAK_VAL_UTF8_(cp_macro, pos, strend) \ (__ASSERT_(pos < strend) \ /* Note assumes is valid UTF-8 */ \ (cp_macro(utf8_to_uv_or_die((pos), (strend), NULL)))) @@ -2225,7 +2225,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { /* Returns the GCB value for the first code point in the UTF-8 encoded string * bounded by pos and strend */ #define getGCB_VAL_UTF8(pos, strend) \ - _generic_GET_BREAK_VAL_UTF8(getGCB_VAL_CP, pos, strend) + generic_GET_BREAK_VAL_UTF8_(getGCB_VAL_CP, pos, strend) /* Returns the LB value for the input code point */ #define getLB_VAL_CP(cp) \ @@ -2237,7 +2237,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { /* Returns the LB value for the first code point in the UTF-8 encoded string * bounded by pos and strend */ #define getLB_VAL_UTF8(pos, strend) \ - _generic_GET_BREAK_VAL_UTF8(getLB_VAL_CP, pos, strend) + generic_GET_BREAK_VAL_UTF8_(getLB_VAL_CP, pos, strend) /* Returns the SB value for the input code point */ @@ -2250,7 +2250,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { /* Returns the SB value for the first code point in the UTF-8 encoded string * bounded by pos and strend */ #define getSB_VAL_UTF8(pos, strend) \ - _generic_GET_BREAK_VAL_UTF8(getSB_VAL_CP, pos, strend) + generic_GET_BREAK_VAL_UTF8_(getSB_VAL_CP, pos, strend) /* Returns the WB value for the input code point */ #define getWB_VAL_CP(cp) \ @@ -2262,7 +2262,7 @@ S_get_break_val_cp_checked(SV* const invlist, const UV cp_in) { /* Returns the WB value for the first code point in the UTF-8 encoded string * bounded by pos and strend */ #define getWB_VAL_UTF8(pos, strend) \ - _generic_GET_BREAK_VAL_UTF8(getWB_VAL_CP, pos, strend) + generic_GET_BREAK_VAL_UTF8_(getWB_VAL_CP, pos, strend) /* We know what class REx starts with. Try to find this position... */ /* if reginfo->intuit, its a dryrun */ From 808d0a64561b5e6cd77cad5b07bc4e7ba712a4d9 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:56:18 -0600 Subject: [PATCH 17/87] regexec.c. Convert _pm_setre to legal name --- op.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/op.h b/op.h index 985b22c93b18..82e28657692e 100644 --- a/op.h +++ b/op.h @@ -317,9 +317,9 @@ struct pmop { /* BEWARE - something that calls this macro passes (r) which has a side effect. */ #define PM_SETRE(o,r) STMT_START { \ - REGEXP *const _pm_setre = (r); \ - assert(_pm_setre); \ - PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(_pm_setre); \ + REGEXP *const pm_setre_ = (r); \ + assert(pm_setre_); \ + PL_regex_pad[(o)->op_pmoffset] = MUTABLE_SV(pm_setre_); \ } STMT_END #else #define PM_GETRE_raw(o) ((o)->op_pmregexp) From 02fa60d26fe3144230d9f5578a3a7d8b97263e44 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 13:57:10 -0600 Subject: [PATCH 18/87] op_reg*.h. Convert _RXm_PMf_SHIFT_NEXT to legal name --- op.h | 6 +++--- op_reg_common.h | 2 +- regexp.h | 6 +++--- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/op.h b/op.h index 82e28657692e..87b5adfa8c42 100644 --- a/op.h +++ b/op.h @@ -330,7 +330,7 @@ struct pmop { /* Currently these PMf flags occupy a single 32-bit word. Not all bits are * currently used. The lower bits are shared with their corresponding RXf flag - * bits, up to but not including _RXf_PMf_SHIFT_NEXT. The unused bits + * bits, up to but not including RXf_PMf_SHIFT_NEXT_. The unused bits * immediately follow; finally the used Pmf-only (unshared) bits, so that the * highest bit in the word is used. This gathers all the unused bits as a pool * in the middle, like so: 11111111111111110000001111111111 @@ -341,7 +341,7 @@ struct pmop { * breaking binary compatibility. * * To add shared bits, do so in op_reg_common.h. This should change - * _RXf_PMf_SHIFT_NEXT so that things won't compile. Then come to regexp.h and + * RXf_PMf_SHIFT_NEXT_ so that things won't compile. Then come to regexp.h and * op.h and adjust the constant adders in the definitions of PMf_BASE_SHIFT and * Pmf_BASE_SHIFT down by the number of shared bits you added. That's it. * Things should be binary compatible. But if either of these gets to having @@ -358,7 +358,7 @@ struct pmop { * allocate off the low end until you get to PMf_BASE_SHIFT+0. If that isn't * enough, move PMf_BASE_SHIFT down (if possible) and add the new bit at the * other end instead; this preserves binary compatibility. */ -#define PMf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT+2) +#define PMf_BASE_SHIFT (RXf_PMf_SHIFT_NEXT_+2) /* Set by the parser if it discovers an error, so the regex shouldn't be * compiled */ diff --git a/op_reg_common.h b/op_reg_common.h index 1273cb6f2195..19cbd8480a7f 100644 --- a/op_reg_common.h +++ b/op_reg_common.h @@ -97,7 +97,7 @@ get_regex_charset(const U32 flags) /* Next available bit after the above. Name begins with '_' so won't be * exported by B */ -#define _RXf_PMf_SHIFT_NEXT (RXf_PMf_STD_PMMOD_SHIFT+12) +#define RXf_PMf_SHIFT_NEXT_ (RXf_PMf_STD_PMMOD_SHIFT+12) /* Mask of the above bits. These need to be transferred from op_pmflags to * re->extflags during compilation */ diff --git a/regexp.h b/regexp.h index c587a9c0586a..b9c099e0902d 100644 --- a/regexp.h +++ b/regexp.h @@ -484,7 +484,7 @@ and check for NULL. /* Currently the regex flags occupy a single 32-bit word. Not all bits are * currently used. The lower bits are shared with their corresponding PMf flag - * bits, up to but not including _RXf_PMf_SHIFT_NEXT. The unused bits + * bits, up to but not including RXf_PMf_SHIFT_NEXT_. The unused bits * immediately follow; finally the used RXf-only (unshared) bits, so that the * highest bit in the word is used. This gathers all the unused bits as a pool * in the middle, like so: 11111111111111110000001111111111 @@ -495,7 +495,7 @@ and check for NULL. * breaking binary compatibility. * * To add shared bits, do so in op_reg_common.h. This should change - * _RXf_PMf_SHIFT_NEXT so that things won't compile. Then come to regexp.h and + * RXf_PMf_SHIFT_NEXT_ so that things won't compile. Then come to regexp.h and * op.h and adjust the constant adders in the definitions of RXf_BASE_SHIFT and * Pmf_BASE_SHIFT down by the number of shared bits you added. That's it. * Things should be binary compatible. But if either of these gets to having @@ -515,7 +515,7 @@ and check for NULL. * For the regexp bits, PL_reg_extflags_name[] in regnodes.h has a comment * giving which bits are used/unused */ -# define RXf_BASE_SHIFT (_RXf_PMf_SHIFT_NEXT + 2) +# define RXf_BASE_SHIFT (RXf_PMf_SHIFT_NEXT_ + 2) /* What we have seen */ # define RXf_NO_INPLACE_SUBST (1U<<(RXf_BASE_SHIFT+2)) From bcf8f930f67c5bdee9215c98026eb3026d7ebe3f Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 14:00:42 -0600 Subject: [PATCH 19/87] op_reg_common.h: Convert _RXf_PMf_CHARSET_SHIFT to legal name --- op_reg_common.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/op_reg_common.h b/op_reg_common.h index 19cbd8480a7f..78c3be03454f 100644 --- a/op_reg_common.h +++ b/op_reg_common.h @@ -51,8 +51,8 @@ typedef enum { REGEX_ASCII_MORE_RESTRICTED_CHARSET } regex_charset; -#define _RXf_PMf_CHARSET_SHIFT ((RXf_PMf_STD_PMMOD_SHIFT)+7) -#define RXf_PMf_CHARSET (7U << (_RXf_PMf_CHARSET_SHIFT)) /* 3 bits */ +#define RXf_PMf_CHARSET_SHIFT_ ((RXf_PMf_STD_PMMOD_SHIFT)+7) +#define RXf_PMf_CHARSET (7U << (RXf_PMf_CHARSET_SHIFT_)) /* 3 bits */ /* Manually decorate these functions here with gcc-style attributes just to * avoid making the regex_charset typedef global, which it would need to be for @@ -68,7 +68,7 @@ set_regex_charset(U32 * const flags, const regex_charset cs) * the above enum */ *flags &= ~RXf_PMf_CHARSET; - *flags |= (cs << _RXf_PMf_CHARSET_SHIFT); + *flags |= (cs << RXf_PMf_CHARSET_SHIFT_); } PERL_STATIC_INLINE regex_charset @@ -80,7 +80,7 @@ get_regex_charset(const U32 flags) { /* Returns the enum corresponding to the character set in 'flags' */ - return (regex_charset) ((flags & RXf_PMf_CHARSET) >> _RXf_PMf_CHARSET_SHIFT); + return (regex_charset) ((flags & RXf_PMf_CHARSET) >> RXf_PMf_CHARSET_SHIFT_); } #define RXf_PMf_STRICT (1U<<(RXf_PMf_STD_PMMOD_SHIFT+10)) From daea3eeb7414f19ceb4a8116761d7bafea99c022 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 14:01:44 -0600 Subject: [PATCH 20/87] op_reg_common.h: Convert _RXf_PMf_COMPILETIME to legal name --- op_reg_common.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/op_reg_common.h b/op_reg_common.h index 78c3be03454f..d6b0db5e1349 100644 --- a/op_reg_common.h +++ b/op_reg_common.h @@ -85,7 +85,7 @@ get_regex_charset(const U32 flags) #define RXf_PMf_STRICT (1U<<(RXf_PMf_STD_PMMOD_SHIFT+10)) -#define _RXf_PMf_SHIFT_COMPILETIME (RXf_PMf_STD_PMMOD_SHIFT+11) +#define RXf_PMf_SHIFT_COMPILETIME_ (RXf_PMf_STD_PMMOD_SHIFT+11) /* @@ -149,7 +149,7 @@ get_regex_charset(const U32 flags) * directly in the #define because doing so confuses regcomp.pl. * (2**n - 1) is n 1 bits, so the below gets the contiguous bits between the * beginning and ending shifts */ -#if RXf_PMf_COMPILETIME != ((nBIT_MASK(_RXf_PMf_SHIFT_COMPILETIME)) \ +#if RXf_PMf_COMPILETIME != ((nBIT_MASK(RXf_PMf_SHIFT_COMPILETIME_)) \ & (~(nBIT_MASK( RXf_PMf_STD_PMMOD_SHIFT)))) # error RXf_PMf_COMPILETIME is invalid #endif From 3c58efa0180d3f8f8ffddbaa4ede4bf4bc2a442e Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 14:12:18 -0600 Subject: [PATCH 21/87] op_reg_common.h: Convert _o to legal name --- scope.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/scope.h b/scope.h index 67e1c07feae2..aa4b1dc8cf76 100644 --- a/scope.h +++ b/scope.h @@ -304,10 +304,10 @@ casts it to a pointer of that C. # define save_freeop(op) \ STMT_START { \ - OP * const _o = (OP *)(op); \ - assert(!_o->op_savefree); \ - _o->op_savefree = 1; \ - save_pushptr((void *)(_o), SAVEt_FREEOP); \ + OP * const o_ = (OP *)(op); \ + assert(!o_->op_savefree); \ + o_->op_savefree = 1; \ + save_pushptr((void *)(o_), SAVEt_FREEOP); \ } STMT_END #define save_freepv(pv) save_pushptr((void *)(pv), SAVEt_FREEPV) From fd251778d4e3da201192ca8903df6b50de76407f Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 14:14:33 -0600 Subject: [PATCH 22/87] regexp.h: Convert _rerefcnt_inc to legal name --- regexp.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/regexp.h b/regexp.h index b9c099e0902d..ccfa35d42599 100644 --- a/regexp.h +++ b/regexp.h @@ -741,10 +741,10 @@ and check for NULL. # define ReREFCNT_inc(re) \ ({ \ /* This is here to generate a casting warning if incorrect. */ \ - REGEXP *const _rerefcnt_inc = (re); \ - assert(SvTYPE(_rerefcnt_inc) == SVt_REGEXP); \ - SvREFCNT_inc(_rerefcnt_inc); \ - _rerefcnt_inc; \ + REGEXP *const rerefcnt_inc_ = (re); \ + assert(SvTYPE(rerefcnt_inc_) == SVt_REGEXP); \ + SvREFCNT_inc(rerefcnt_inc_); \ + rerefcnt_inc_; \ }) # define ReREFCNT_dec(re) \ ({ \ From aca339f53f0eaabb80ba0720a3b85685369ba217 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 14:14:50 -0600 Subject: [PATCH 23/87] regexp.h: Convert _rerefcnt_dec to legal name --- regexp.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/regexp.h b/regexp.h index ccfa35d42599..57bc98a1adff 100644 --- a/regexp.h +++ b/regexp.h @@ -749,8 +749,8 @@ and check for NULL. # define ReREFCNT_dec(re) \ ({ \ /* This is here to generate a casting warning if incorrect. */ \ - REGEXP *const _rerefcnt_dec = (re); \ - SvREFCNT_dec(_rerefcnt_dec); \ + REGEXP *const rerefcnt_dec_ = (re); \ + SvREFCNT_dec(rerefcnt_dec_); \ }) #else # define ReREFCNT_dec(re) SvREFCNT_dec(re) From 078590cd738151706e1f6ff3ac3af8309ec4da1c Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:11:55 -0600 Subject: [PATCH 24/87] regcomp.h: Convert _reg_trie_trans to legal name --- regcomp.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/regcomp.h b/regcomp.h index 7a20b54fdf1d..5870d0d1530a 100644 --- a/regcomp.h +++ b/regcomp.h @@ -1189,7 +1189,7 @@ struct reg_data { field. the next field determines which state is to be transitioned to if any. */ -struct _reg_trie_trans { +struct reg_trie_trans_ { U32 next; U32 check; }; @@ -1226,7 +1226,7 @@ typedef struct { typedef struct _reg_trie_state reg_trie_state; -typedef struct _reg_trie_trans reg_trie_trans; +typedef struct reg_trie_trans_ reg_trie_trans; /* anything in here that needs to be freed later From dd9f7eb4b7af81208b42513a29f883f5d27a4d62 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:14:04 -0600 Subject: [PATCH 25/87] regcomp.h: Convert _reg_trie_trans_list_elem to legal name --- regcomp.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/regcomp.h b/regcomp.h index 5870d0d1530a..a0158b149fe2 100644 --- a/regcomp.h +++ b/regcomp.h @@ -1195,11 +1195,11 @@ struct reg_trie_trans_ { }; /* a transition list element for the list based representation */ -struct _reg_trie_trans_list_elem { +struct reg_trie_trans_list_elem_ { U16 forid; U32 newstate; }; -typedef struct _reg_trie_trans_list_elem reg_trie_trans_le; +typedef struct reg_trie_trans_list_elem_ reg_trie_trans_le; /* a state for compressed nodes. base is an offset into an array of reg_trie_trans array. If wordnum is From fe9fe2dda0014a70ec3fdd2739ae7ea838cca9e8 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:14:54 -0600 Subject: [PATCH 26/87] regcomp.h: Convert _reg_trie_state to legal name --- regcomp.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/regcomp.h b/regcomp.h index a0158b149fe2..72c81d36f8cd 100644 --- a/regcomp.h +++ b/regcomp.h @@ -1206,7 +1206,7 @@ typedef struct reg_trie_trans_list_elem_ reg_trie_trans_le; nonzero the state is accepting. if base is zero then the state has no children (and will be accepting) */ -struct _reg_trie_state { +struct reg_trie_state_ { U16 wordnum; union { U32 base; @@ -1225,7 +1225,7 @@ typedef struct { } reg_trie_wordinfo; -typedef struct _reg_trie_state reg_trie_state; +typedef struct reg_trie_state_ reg_trie_state; typedef struct reg_trie_trans_ reg_trie_trans; From ca3410611a5e8b9ef2fd884233aa852561dc019d Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:15:58 -0600 Subject: [PATCH 27/87] regcomp.h: Convert _reg_trie_data to legal name --- embed.fnc | 6 +++--- perl.h | 2 +- proto.h | 6 +++--- regcomp.h | 6 +++--- regcomp_trie.c | 6 +++--- 5 files changed, 13 insertions(+), 13 deletions(-) diff --git a/embed.fnc b/embed.fnc index 8e32ba20ce9a..23614d127599 100644 --- a/embed.fnc +++ b/embed.fnc @@ -5366,18 +5366,18 @@ Ep |SSize_t|study_chunk |NN RExC_state_t *pRExC_state \ |U32 depth \ |bool was_mutate_ok # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) -ES |void |dump_trie |NN const struct _reg_trie_data *trie \ +ES |void |dump_trie |NN const struct reg_trie_data_ *trie \ |NULLOK HV *widecharmap \ |NN AV *revcharmap \ |U32 depth ES |void |dump_trie_interim_list \ - |NN const struct _reg_trie_data *trie \ + |NN const struct reg_trie_data_ *trie \ |NULLOK HV *widecharmap \ |NN AV *revcharmap \ |U32 next_alloc \ |U32 depth ES |void |dump_trie_interim_table \ - |NN const struct _reg_trie_data *trie \ + |NN const struct reg_trie_data_ *trie \ |NULLOK HV *widecharmap \ |NN AV *revcharmap \ |U32 next_alloc \ diff --git a/perl.h b/perl.h index ee92716971ab..4e85a5a720a4 100644 --- a/perl.h +++ b/perl.h @@ -4574,7 +4574,7 @@ typedef struct regnode_charclass_posixl regnode_charclass_posixl; typedef struct regnode_ssc regnode_ssc; typedef struct RExC_state_t RExC_state_t; -struct _reg_trie_data; +struct reg_trie_data_; typedef struct scan_data_t scan_data_t; #endif diff --git a/proto.h b/proto.h index 64d50774ad2e..8dee442e08c0 100644 --- a/proto.h +++ b/proto.h @@ -8322,11 +8322,11 @@ Perl_study_chunk(pTHX_ RExC_state_t *pRExC_state, regnode **scanp, SSize_t *minl __attribute__visibility__("hidden"); # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) STATIC void -S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 depth); +S_dump_trie(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 depth); STATIC void -S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); +S_dump_trie_interim_list(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); STATIC void -S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); +S_dump_trie_interim_table(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth); # endif # endif /* defined(PERL_CORE) || defined(PERL_EXT) */ # if defined(PERL_IN_REGCOMP_TRIE_C) && defined(DEBUGGING) diff --git a/regcomp.h b/regcomp.h index 72c81d36f8cd..4f1600e94ae7 100644 --- a/regcomp.h +++ b/regcomp.h @@ -1233,7 +1233,7 @@ typedef struct reg_trie_trans_ reg_trie_trans; should be dealt with in pregfree. refcount is first in both this and _reg_ac_data to allow a space optimisation in Perl_regdupe. */ -struct _reg_trie_data { +struct reg_trie_data_ { U32 refcount; /* number of times this trie is referenced */ U32 lasttrans; /* last valid transition element */ U16 *charmap; /* byte to charid lookup array */ @@ -1274,9 +1274,9 @@ struct _reg_trie_data { #define TRIE_WORDS_OFFSET 2 -typedef struct _reg_trie_data reg_trie_data; +typedef struct reg_trie_data_ reg_trie_data; -/* refcount is first in both this and _reg_trie_data to allow a space +/* refcount is first in both this and reg_trie_data_ to allow a space optimisation in Perl_regdupe. */ struct _reg_ac_data { U32 refcount; diff --git a/regcomp_trie.c b/regcomp_trie.c index 7cd55023e775..f3863bcb830d 100644 --- a/regcomp_trie.c +++ b/regcomp_trie.c @@ -48,7 +48,7 @@ */ STATIC void -S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, +S_dump_trie(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 depth) { U32 state; @@ -142,7 +142,7 @@ S_dump_trie(pTHX_ const struct _reg_trie_data *trie, HV *widecharmap, Used for debugging make_trie(). */ STATIC void -S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, +S_dump_trie_interim_list(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) { @@ -202,7 +202,7 @@ S_dump_trie_interim_list(pTHX_ const struct _reg_trie_data *trie, Used for debugging make_trie(). */ STATIC void -S_dump_trie_interim_table(pTHX_ const struct _reg_trie_data *trie, +S_dump_trie_interim_table(pTHX_ const struct reg_trie_data_ *trie, HV *widecharmap, AV *revcharmap, U32 next_alloc, U32 depth) { From 268bdca4cf8c066165f27660b32d9997be13358d Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:17:22 -0600 Subject: [PATCH 28/87] regcomp.h: Convert _reg_ac_data to legal name --- regcomp.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/regcomp.h b/regcomp.h index 4f1600e94ae7..31ccddf1724b 100644 --- a/regcomp.h +++ b/regcomp.h @@ -1231,7 +1231,7 @@ typedef struct reg_trie_trans_ reg_trie_trans; /* anything in here that needs to be freed later should be dealt with in pregfree. - refcount is first in both this and _reg_ac_data to allow a space + refcount is first in both this and reg_ac_data_ to allow a space optimisation in Perl_regdupe. */ struct reg_trie_data_ { U32 refcount; /* number of times this trie is referenced */ @@ -1278,13 +1278,13 @@ typedef struct reg_trie_data_ reg_trie_data; /* refcount is first in both this and reg_trie_data_ to allow a space optimisation in Perl_regdupe. */ -struct _reg_ac_data { +struct reg_ac_data_ { U32 refcount; U32 trie; U32 *fail; reg_trie_state *states; }; -typedef struct _reg_ac_data reg_ac_data; +typedef struct reg_ac_data_ reg_ac_data; /* ANY_BIT doesn't use the structure, so we can borrow it here. This is simpler than refactoring all of it as wed end up with From a1e0eb46810b1989293d650fe6d8733542214789 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 12:47:16 -0600 Subject: [PATCH 29/87] regcomp_trie.c. Convert _eC to legal name --- thread.h | 84 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 42 insertions(+), 42 deletions(-) diff --git a/thread.h b/thread.h index 8af458d59441..b058c7bd68dd 100644 --- a/thread.h +++ b/thread.h @@ -20,11 +20,11 @@ # ifdef OLD_PTHREADS_API /* Here be dragons. */ # define DETACH(t) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_detach(&(t)->self))) { \ + int eC_; \ + if ((eC_ = pthread_detach(&(t)->self))) { \ MUTEX_UNLOCK(&(t)->mutex); \ Perl_croak_nocontext("panic: DETACH (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } \ } STMT_END @@ -179,19 +179,19 @@ /* Temporary workaround, true bug is deeper. --jhi 1999-02-25 */ # define MUTEX_INIT(m) \ STMT_START { \ - int _eC_; \ + int eC_; \ Zero((m), 1, perl_mutex); \ - if ((_eC_ = pthread_mutex_init((m), pthread_mutexattr_default)))\ + if ((eC_ = pthread_mutex_init((m), pthread_mutexattr_default)))\ Perl_croak_nocontext("panic: MUTEX_INIT (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } STMT_END # else # define MUTEX_INIT(m) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_mutex_init((m), pthread_mutexattr_default))) \ + int eC_; \ + if ((eC_ = pthread_mutex_init((m), pthread_mutexattr_default))) \ Perl_croak_nocontext("panic: MUTEX_INIT (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } STMT_END # endif @@ -206,33 +206,33 @@ # define MUTEX_LOCK(m) \ STMT_START { \ dSAVE_ERRNO; \ - int _eC_; \ - if ((_eC_ = perl_pthread_mutex_lock((m)))) \ + int eC_; \ + if ((eC_ = perl_pthread_mutex_lock((m)))) \ Perl_croak_nocontext("panic: MUTEX_LOCK (%d) [%s:%d]",\ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ RESTORE_ERRNO; \ } STMT_END # define MUTEX_UNLOCK(m) \ STMT_START { \ dSAVE_ERRNO; /* Shouldn't be necessary as panics if fails */\ - int _eC_; \ - if ((_eC_ = perl_pthread_mutex_unlock((m)))) { \ + int eC_; \ + if ((eC_ = perl_pthread_mutex_unlock((m)))) { \ Perl_croak_nocontext( \ "panic: MUTEX_UNLOCK (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } \ RESTORE_ERRNO; \ } STMT_END # define MUTEX_DESTROY(m) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_mutex_destroy((m)))) { \ + int eC_; \ + if ((eC_ = pthread_mutex_destroy((m)))) { \ dTHX; \ if (PL_phase != PERL_PHASE_DESTRUCT) { \ Perl_croak_nocontext("panic: MUTEX_DESTROY (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } \ } \ } STMT_END @@ -241,44 +241,44 @@ #ifndef COND_INIT # define COND_INIT(c) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_cond_init((c), pthread_condattr_default))) \ + int eC_; \ + if ((eC_ = pthread_cond_init((c), pthread_condattr_default))) \ Perl_croak_nocontext("panic: COND_INIT (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } STMT_END # define COND_SIGNAL(c) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_cond_signal((c)))) \ + int eC_; \ + if ((eC_ = pthread_cond_signal((c)))) \ Perl_croak_nocontext("panic: COND_SIGNAL (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } STMT_END # define COND_BROADCAST(c) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_cond_broadcast((c)))) \ + int eC_; \ + if ((eC_ = pthread_cond_broadcast((c)))) \ Perl_croak_nocontext("panic: COND_BROADCAST (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } STMT_END # define COND_WAIT(c, m) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_cond_wait((c), (m)))) \ + int eC_; \ + if ((eC_ = pthread_cond_wait((c), (m)))) \ Perl_croak_nocontext("panic: COND_WAIT (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } STMT_END # define COND_DESTROY(c) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_cond_destroy((c)))) { \ + int eC_; \ + if ((eC_ = pthread_cond_destroy((c)))) { \ dTHX; \ if (PL_phase != PERL_PHASE_DESTRUCT) { \ Perl_croak_nocontext("panic: COND_DESTROY (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } \ } \ } STMT_END @@ -357,11 +357,11 @@ #ifndef DETACH # define DETACH(t) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_detach((t)->self))) { \ + int eC_; \ + if ((eC_ = pthread_detach((t)->self))) { \ MUTEX_UNLOCK(&(t)->mutex); \ Perl_croak_nocontext("panic: DETACH (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } \ } STMT_END #endif /* DETACH */ @@ -369,10 +369,10 @@ #ifndef JOIN # define JOIN(t, avp) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_join((t)->self, (void**)(avp)))) \ + int eC_; \ + if ((eC_ = pthread_join((t)->self, (void**)(avp)))) \ Perl_croak_nocontext("panic: pthread_join (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ } STMT_END #endif /* JOIN */ @@ -410,11 +410,11 @@ extern PERL_THREAD_LOCAL void *PL_current_context; # define PERL_SET_CONTEXT(t) \ STMT_START { \ - int _eC_; \ - if ((_eC_ = pthread_setspecific(PL_thr_key, \ + int eC_; \ + if ((eC_ = pthread_setspecific(PL_thr_key, \ PL_current_context = (void *)(t)))) \ Perl_croak_nocontext("panic: pthread_setspecific (%d) [%s:%d]", \ - _eC_, __FILE__, __LINE__); \ + eC_, __FILE__, __LINE__); \ PERL_SET_NON_tTHX_CONTEXT(t); \ } STMT_END From 5c4e3db7c5ceb5a410c24cfa18e6b3e820463f91 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:23:11 -0600 Subject: [PATCH 30/87] Convert _byte_dump_string() to legal name --- embed.fnc | 2 +- embed.h | 2 +- locale.c | 12 ++++++------ op.c | 6 +++--- proto.h | 8 ++++---- regcomp_debug.c | 2 +- utf8.c | 26 +++++++++++++------------- 7 files changed, 29 insertions(+), 29 deletions(-) diff --git a/embed.fnc b/embed.fnc index 23614d127599..23af64c288c9 100644 --- a/embed.fnc +++ b/embed.fnc @@ -806,7 +806,7 @@ p |OP * |build_infix_plugin \ |NN OP *lhs \ |NN OP *rhs \ |NN void *tokendata -EXp |const char *|_byte_dump_string \ +EXp |const char *|byte_dump_string_ \ |NULLOK const U8 * const start \ |const STRLEN len \ |const bool format diff --git a/embed.h b/embed.h index 3ccf89db85ca..4b2d0b8faf5a 100644 --- a/embed.h +++ b/embed.h @@ -1798,10 +1798,10 @@ # endif # endif /* defined(PERL_CORE) */ # if defined(PERL_CORE) || defined(PERL_EXT) -# define _byte_dump_string(a,b,c) Perl__byte_dump_string(aTHX_ a,b,c) # define _inverse_folds(a,b,c) Perl__inverse_folds(aTHX_ a,b,c) # define append_utf8_from_native_byte Perl_append_utf8_from_native_byte # define av_reify(a) Perl_av_reify(aTHX_ a) +# define byte_dump_string_(a,b,c) Perl_byte_dump_string_(aTHX_ a,b,c) # define cntrl_to_mnemonic Perl_cntrl_to_mnemonic # define current_re_engine() Perl_current_re_engine(aTHX) # define cv_ckproto_len_flags(a,b,c,d,e) Perl_cv_ckproto_len_flags(aTHX_ a,b,c,d,e) diff --git a/locale.c b/locale.c index b93526ba0924..5eed234b9a5e 100644 --- a/locale.c +++ b/locale.c @@ -4779,7 +4779,7 @@ S_get_locale_string_utf8ness_i(pTHX_ const char * string, " index=%u(%s), string=%s, known_utf8=%d\n", locale, cat_index, category_names[cat_index], ((string) - ? _byte_dump_string((U8 *) string, + ? byte_dump_string_((U8 *) string, strlen(string), 0) : "nil"), @@ -5088,7 +5088,7 @@ S_save_to_buffer(pTHX_ const char * string, char **buf, Size_t *buf_size) "Copying '%s' to 0x%p\n", ((is_strict_utf8_string((U8 *) string, 0)) ? string - :_byte_dump_string((U8 *) string, strlen(string), 0)), + :byte_dump_string_((U8 *) string, strlen(string), 0)), *buf)); # ifdef USE_LOCALE_CTYPE @@ -6695,7 +6695,7 @@ S_langinfo_sv_i(pTHX_ locale_panic_(form( "Can't find separator in ALT_DIGITS" " representation '%s' for locale '%s'", - _byte_dump_string((U8 *) retval, + byte_dump_string_((U8 *) retval, total_len, 0), locale)); } @@ -8683,7 +8683,7 @@ S_strftime8(pTHX_ const char * fmt, fmt, ((is_strict_utf8_string((U8 *) SvPVX(sv), 0)) ? SvPVX(sv) - :_byte_dump_string((U8 *) SvPVX(sv), SvCUR(sv) ,0)), + :byte_dump_string_((U8 *) SvPVX(sv), SvCUR(sv) ,0)), *result_utf8ness)); Safefree(free_me); return true; @@ -10178,7 +10178,7 @@ Perl_mem_collxfrm_(pTHX_ const char *input_string, DEBUG_L(PerlIO_printf(Perl_debug_log, "strxfrm failed for LC_COLLATE=%s; errno=%d, input=%s\n", PL_collation_name, errno, - _byte_dump_string((U8 *) s, len, 0))); + byte_dump_string_((U8 *) s, len, 0))); goto bad; } @@ -10340,7 +10340,7 @@ S_print_collxfrm_input_and_return(pTHX_ ? "(null)" : ((xlen == 0) ? "(empty)" - : _byte_dump_string((U8 *) xbuf + COLLXFRM_HDR_LEN, + : byte_dump_string_((U8 *) xbuf + COLLXFRM_HDR_LEN, xlen, 0))), xlen); } diff --git a/op.c b/op.c index c25447071126..cb232fa86138 100644 --- a/op.c +++ b/op.c @@ -6569,7 +6569,7 @@ S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl) DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d: tstr before inversion=\n%s\n", - __FILE__, __LINE__, _byte_dump_string(t, tend - t, 0))); + __FILE__, __LINE__, byte_dump_string_(t, tend - t, 0))); while (t < tend) { @@ -6732,9 +6732,9 @@ S_pmtrans(pTHX_ OP *o, OP *expr, OP *repl) t_range_count = r_range_count = 0; DEBUG_y(PerlIO_printf(Perl_debug_log, "%s: %d:\ntstr=%s\n", - __FILE__, __LINE__, _byte_dump_string(t, tend - t, 0))); + __FILE__, __LINE__, byte_dump_string_(t, tend - t, 0))); DEBUG_y(PerlIO_printf(Perl_debug_log, "rstr=%s\n", - _byte_dump_string(r, rend - r, 0))); + byte_dump_string_(r, rend - r, 0))); DEBUG_y(PerlIO_printf(Perl_debug_log, "/c=%d; /s=%d; /d=%d\n" " At the beginning of pass %u\n", complement, squash, del, diff --git a/proto.h b/proto.h index 8dee442e08c0..2edc4d2bb807 100644 --- a/proto.h +++ b/proto.h @@ -88,8 +88,6 @@ Perl_Slab_Free(pTHX_ void *op); /* PERL_CALLCONV void Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ -#define PERL_ARGS_ASSERT__BYTE_DUMP_STRING - #define PERL_ARGS_ASSERT__INVERSE_FOLDS \ assert(first_folds_to); assert(remaining_folds_to) @@ -388,6 +386,8 @@ Perl_build_infix_plugin(pTHX_ OP *lhs, OP *rhs, void *tokendata) #define PERL_ARGS_ASSERT_BUILD_INFIX_PLUGIN \ assert(lhs); assert(rhs); assert(tokendata) +#define PERL_ARGS_ASSERT_BYTE_DUMP_STRING_ + PERL_CALLCONV int Perl_bytes_cmp_utf8(pTHX_ const U8 *b, STRLEN blen, const U8 *u, STRLEN ulen); #define PERL_ARGS_ASSERT_BYTES_CMP_UTF8 \ @@ -6039,14 +6039,14 @@ S_should_warn_nl(const char *pv) # endif #endif /* defined(PERL_CORE) */ #if defined(PERL_CORE) || defined(PERL_EXT) -PERL_CALLCONV const char * -Perl__byte_dump_string(pTHX_ const U8 * const start, const STRLEN len, const bool format); PERL_CALLCONV Size_t Perl__inverse_folds(pTHX_ const UV cp, U32 *first_folds_to, const U32 **remaining_folds_to) __attribute__warn_unused_result__; PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av); PERL_CALLCONV const char * +Perl_byte_dump_string_(pTHX_ const U8 * const start, const STRLEN len, const bool format); +PERL_CALLCONV const char * Perl_cntrl_to_mnemonic(const U8 c) __attribute__warn_unused_result__; PERL_CALLCONV regexp_engine const * diff --git a/regcomp_debug.c b/regcomp_debug.c index 218908f1da9a..805ca7f31fd0 100644 --- a/regcomp_debug.c +++ b/regcomp_debug.c @@ -946,7 +946,7 @@ Perl_regprop(pTHX_ const regexp *prog, SV *sv, const regnode *o, const regmatch_ if (op == ANYOFHs) { sv_catpvf(sv, " (Leading UTF-8 bytes = %s", - _byte_dump_string((U8 *) ((struct regnode_anyofhs *) o)->string, + byte_dump_string_((U8 *) ((struct regnode_anyofhs *) o)->string, FLAGS(o), 1)); } else if (REGNODE_TYPE(op) != ANYOF) { diff --git a/utf8.c b/utf8.c index 20398ee514f8..4d55c431557f 100644 --- a/utf8.c +++ b/utf8.c @@ -885,7 +885,7 @@ Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, } const char * -Perl__byte_dump_string(pTHX_ const U8 * const start, const STRLEN len, const bool format) +Perl_byte_dump_string_(pTHX_ const U8 * const start, const STRLEN len, const bool format) { /* Returns a mortalized C string that is a displayable copy of the 'len' * bytes starting at 'start'. 'format' gives how to display each byte. @@ -905,7 +905,7 @@ Perl__byte_dump_string(pTHX_ const U8 * const start, const STRLEN len, const boo char * output; char * d; - PERL_ARGS_ASSERT__BYTE_DUMP_STRING; + PERL_ARGS_ASSERT_BYTE_DUMP_STRING_; Newx(output, output_len, char); SAVEFREEPV(output); @@ -985,7 +985,7 @@ S_unexpected_non_continuation_text(pTHX_ const U8 * const s, return form("%s: %s (unexpected non-continuation byte 0x%02x," " %s after start byte 0x%02x; need %d bytes, got %d)", malformed_text, - _byte_dump_string(s, x - s, 0), + byte_dump_string_(s, x - s, 0), *(s + non_cont_byte_pos), where, *s, @@ -2249,7 +2249,7 @@ Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, "%s: %s (unexpected continuation byte 0x%02x," " with no preceding start byte)", malformed_text, - _byte_dump_string(s0, 1, 0), + byte_dump_string_(s0, 1, 0), *s0); break; @@ -2258,7 +2258,7 @@ Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, message = form( "%s: %s (too short; %d byte%s available, need %d)", malformed_text, - _byte_dump_string(s0, avail_len, 0), + byte_dump_string_(s0, avail_len, 0), (int)avail_len, avail_len == 1 ? "" : "s", /* Pluralize */ (int)expectlen); @@ -2296,8 +2296,8 @@ Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, " \"%s\" is overlong which can and should be" " represented with a different, shorter sequence)", malformed_text, - _byte_dump_string(s0, send - s0, 0), - _byte_dump_string(s0, curlen, 0)); + byte_dump_string_(s0, send - s0, 0), + byte_dump_string_(s0, curlen, 0)); } else { U8 tmpbuf[UTF8_MAXBYTES+1]; @@ -2317,8 +2317,8 @@ Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, "%s: %s (overlong; instead use %s to represent" " %s%0*" UVXf ")", malformed_text, - _byte_dump_string(s0, avail_len, 0), - _byte_dump_string(tmpbuf, e - tmpbuf, 0), + byte_dump_string_(s0, avail_len, 0), + byte_dump_string_(tmpbuf, e - tmpbuf, 0), preface, ((input_uv < 256) ? 2 : 4), /* Field width of 2 for small code @@ -2366,7 +2366,7 @@ Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, message = Perl_form(aTHX_ "UTF-16 surrogate (any UTF-8 sequence that" " starts with \"%s\" is for a surrogate)", - _byte_dump_string(s0, curlen, 0)); + byte_dump_string_(s0, curlen, 0)); } else { message = Perl_form(aTHX_ surrogate_cp_format, input_uv); @@ -2456,7 +2456,7 @@ Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, if (overflows) { message = Perl_form(aTHX_ "%s: %s (overflows)", malformed_text, - _byte_dump_string(s0, curlen, 0)); + byte_dump_string_(s0, curlen, 0)); } else if ( (orig_problems & UTF8_GOT_TOO_SHORT) || ( UTF8_IS_PERL_EXTENDED(s0) @@ -2467,14 +2467,14 @@ Perl_utf8_to_uv_msgs_helper_(const U8 * const s0, "Any UTF-8 sequence that starts with" " \"%s\" is a Perl extension, and so" " is not portable", - _byte_dump_string(s0, curlen, 0)); + byte_dump_string_(s0, curlen, 0)); } else { message = Perl_form(aTHX_ "Any UTF-8 sequence that starts with" " \"%s\" is for a non-Unicode code" " point, may not be portable", - _byte_dump_string(s0, curlen, 0)); + byte_dump_string_(s0, curlen, 0)); } } else if (is_extended) { From 3869d811a1dbaf5e6aacfb4d8db635cacb33554f Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:26:23 -0600 Subject: [PATCH 31/87] gv.h: Convert _gvgp to legal name --- gv.h | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/gv.h b/gv.h index 6d3dce6016e5..fac2cd08d106 100644 --- a/gv.h +++ b/gv.h @@ -46,15 +46,15 @@ the need to cast the result to the appropriate type. #if defined (DEBUGGING) && defined(PERL_USE_GCC_BRACE_GROUPS) && !defined(__INTEL_COMPILER) # define GvGP(gv) \ - ((GP *)(*({GV *const _gvgp = (GV *) (gv); \ - assert(SvTYPE(_gvgp) == SVt_PVGV || SvTYPE(_gvgp) == SVt_PVLV); \ - assert(isGV_with_GP(_gvgp)); \ - &((_gvgp)->sv_u.svu_gp);}))) + ((GP *)(*({GV *const gvgp_ = (GV *) (gv); \ + assert(SvTYPE(gvgp_) == SVt_PVGV || SvTYPE(gvgp_) == SVt_PVLV); \ + assert(isGV_with_GP(gvgp_)); \ + &((gvgp_)->sv_u.svu_gp);}))) # define GvGP_set(gv,gp) \ - {GV *const _gvgp = (GV *) (gv); \ - assert(SvTYPE(_gvgp) == SVt_PVGV || SvTYPE(_gvgp) == SVt_PVLV); \ - assert(isGV_with_GP(_gvgp)); \ - (_gvgp)->sv_u.svu_gp = (gp); } + {GV *const gvgp_ = (GV *) (gv); \ + assert(SvTYPE(gvgp_) == SVt_PVGV || SvTYPE(gvgp_) == SVt_PVLV); \ + assert(isGV_with_GP(gvgp_)); \ + (gvgp_)->sv_u.svu_gp = (gp); } # define GvFLAGS(gv) \ (*({GV *const _gvflags = (GV *) (gv); \ assert(SvTYPE(_gvflags) == SVt_PVGV || SvTYPE(_gvflags) == SVt_PVLV); \ From 39b92761722932ff09df7a10b55363758abf4edf Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:27:06 -0600 Subject: [PATCH 32/87] gv.h: Convert _gvflags to legal name --- gv.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/gv.h b/gv.h index fac2cd08d106..86937e3957ea 100644 --- a/gv.h +++ b/gv.h @@ -56,10 +56,10 @@ the need to cast the result to the appropriate type. assert(isGV_with_GP(gvgp_)); \ (gvgp_)->sv_u.svu_gp = (gp); } # define GvFLAGS(gv) \ - (*({GV *const _gvflags = (GV *) (gv); \ - assert(SvTYPE(_gvflags) == SVt_PVGV || SvTYPE(_gvflags) == SVt_PVLV); \ - assert(isGV_with_GP(_gvflags)); \ - &(GvXPVGV(_gvflags)->xpv_cur);})) + (*({GV *const gvflags_ = (GV *) (gv); \ + assert(SvTYPE(gvflags_) == SVt_PVGV || SvTYPE(gvflags_) == SVt_PVLV); \ + assert(isGV_with_GP(gvflags_)); \ + &(GvXPVGV(gvflags_)->xpv_cur);})) # define GvSTASH(gv) \ (*({ GV * const _gvstash = (GV *) (gv); \ assert(isGV_with_GP(_gvstash)); \ From d1fd1f6f16f324b33f40bdee8f98d17560b420b5 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:27:24 -0600 Subject: [PATCH 33/87] gv.h: Convert _gvstash to legal name --- gv.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/gv.h b/gv.h index 86937e3957ea..2a0c35568fea 100644 --- a/gv.h +++ b/gv.h @@ -61,10 +61,10 @@ the need to cast the result to the appropriate type. assert(isGV_with_GP(gvflags_)); \ &(GvXPVGV(gvflags_)->xpv_cur);})) # define GvSTASH(gv) \ - (*({ GV * const _gvstash = (GV *) (gv); \ - assert(isGV_with_GP(_gvstash)); \ - assert(SvTYPE(_gvstash) == SVt_PVGV || SvTYPE(_gvstash) >= SVt_PVLV); \ - &(GvXPVGV(_gvstash)->xnv_u.xgv_stash); \ + (*({ GV * const gvstash_ = (GV *) (gv); \ + assert(isGV_with_GP(gvstash_)); \ + assert(SvTYPE(gvstash_) == SVt_PVGV || SvTYPE(gvstash_) >= SVt_PVLV); \ + &(GvXPVGV(gvstash_)->xnv_u.xgv_stash); \ })) # define GvNAME_HEK(gv) \ (*({ GV * const _gvname_hek = (GV *) (gv); \ From d37cfed3ddcf4eb5bf9f29d6a210bbf1a439fded Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:27:46 -0600 Subject: [PATCH 34/87] gv.h: Convert _gvname_hek to legal name --- gv.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/gv.h b/gv.h index 2a0c35568fea..ec53b29029d9 100644 --- a/gv.h +++ b/gv.h @@ -67,10 +67,10 @@ the need to cast the result to the appropriate type. &(GvXPVGV(gvstash_)->xnv_u.xgv_stash); \ })) # define GvNAME_HEK(gv) \ - (*({ GV * const _gvname_hek = (GV *) (gv); \ - assert(isGV_with_GP(_gvname_hek)); \ - assert(SvTYPE(_gvname_hek) == SVt_PVGV || SvTYPE(_gvname_hek) >= SVt_PVLV); \ - &(GvXPVGV(_gvname_hek)->xiv_u.xivu_namehek); \ + (*({ GV * const gvname_hek_ = (GV *) (gv); \ + assert(isGV_with_GP(gvname_hek_)); \ + assert(SvTYPE(gvname_hek_) == SVt_PVGV || SvTYPE(gvname_hek_) >= SVt_PVLV); \ + &(GvXPVGV(gvname_hek_)->xiv_u.xivu_namehek); \ })) # define GvNAME_get(gv) ({ assert(GvNAME_HEK(gv)); (char *)HEK_KEY(GvNAME_HEK(gv)); }) # define GvNAMELEN_get(gv) ({ assert(GvNAME_HEK(gv)); HEK_LEN(GvNAME_HEK(gv)); }) From 2a628858cb931a387693f5345964ddd5f66a6db0 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:28:53 -0600 Subject: [PATCH 35/87] gv.h: Convert _xhvnameu to legal name --- hv.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/hv.h b/hv.h index f603fcc07f0a..ae4901bada6e 100644 --- a/hv.h +++ b/hv.h @@ -107,7 +107,7 @@ struct mro_meta { Don't access this directly. */ -union _xhvnameu { +union xhvnameu_ { HEK *xhvnameu_name; /* When xhv_name_count is 0 */ HEK **xhvnameu_names; /* When xhv_name_count is non-0 */ }; @@ -116,7 +116,7 @@ union _xhvnameu { struct suspended_compcv; struct xpvhv_aux { - union _xhvnameu xhv_name_u; /* name, if a symbol table */ + union xhvnameu_ xhv_name_u; /* name, if a symbol table */ AV *xhv_backreferences; /* back references for weak references */ HE *xhv_eiter; /* current entry of iterator */ I32 xhv_riter; /* current root of iterator */ From 620b131570fd1a357e3128087c151b5045499219 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:32:22 -0600 Subject: [PATCH 36/87] perl.h: Convert _restore_LC_NUMERIC_function to legal name --- perl.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/perl.h b/perl.h index 4e85a5a720a4..69285748718b 100644 --- a/perl.h +++ b/perl.h @@ -7823,7 +7823,7 @@ cannot have changed since the precalculation. (! PL_numeric_underlying && PL_numeric_standard < 2) # define DECLARATION_FOR_LC_NUMERIC_MANIPULATION \ - void (*_restore_LC_NUMERIC_function)(pTHX_ const char * const file, \ + void (*restore_LC_NUMERIC_function_)(pTHX_ const char * const file, \ const line_t line) = NULL # define STORE_LC_NUMERIC_SET_TO_NEEDED_IN(in) \ @@ -7835,14 +7835,14 @@ cannot have changed since the precalculation. if (_in_lc_numeric) { \ if (NOT_IN_NUMERIC_UNDERLYING_) { \ Perl_set_numeric_underlying(aTHX_ __FILE__, __LINE__); \ - _restore_LC_NUMERIC_function \ + restore_LC_NUMERIC_function_ \ = &Perl_set_numeric_standard; \ } \ } \ else { \ if (NOT_IN_NUMERIC_STANDARD_) { \ Perl_set_numeric_standard(aTHX_ __FILE__, __LINE__); \ - _restore_LC_NUMERIC_function \ + restore_LC_NUMERIC_function_ \ = &Perl_set_numeric_underlying; \ } \ } \ @@ -7853,8 +7853,8 @@ cannot have changed since the precalculation. # define RESTORE_LC_NUMERIC() \ STMT_START { \ - if (_restore_LC_NUMERIC_function) { \ - _restore_LC_NUMERIC_function(aTHX_ __FILE__, __LINE__); \ + if (restore_LC_NUMERIC_function_) { \ + restore_LC_NUMERIC_function_(aTHX_ __FILE__, __LINE__); \ } \ LC_NUMERIC_UNLOCK; \ } STMT_END @@ -7888,7 +7888,7 @@ cannot have changed since the precalculation. STMT_START { \ LC_NUMERIC_LOCK(NOT_IN_NUMERIC_STANDARD_); \ if (NOT_IN_NUMERIC_STANDARD_) { \ - _restore_LC_NUMERIC_function = &Perl_set_numeric_underlying;\ + restore_LC_NUMERIC_function_ = &Perl_set_numeric_underlying;\ Perl_set_numeric_standard(aTHX_ __FILE__, __LINE__); \ } \ } STMT_END @@ -7900,7 +7900,7 @@ cannot have changed since the precalculation. LC_NUMERIC_LOCK(NOT_IN_NUMERIC_UNDERLYING_); \ if (NOT_IN_NUMERIC_UNDERLYING_) { \ Perl_set_numeric_underlying(aTHX_ __FILE__, __LINE__); \ - _restore_LC_NUMERIC_function = &Perl_set_numeric_standard; \ + restore_LC_NUMERIC_function_ = &Perl_set_numeric_standard; \ } \ } STMT_END From fa732cb230e75143e0b3f3e0d8cddadaa0da6e71 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:33:03 -0600 Subject: [PATCH 37/87] perl.h: Convert _in_lc_numeric to legal name --- perl.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/perl.h b/perl.h index 69285748718b..41e1fc66c120 100644 --- a/perl.h +++ b/perl.h @@ -7828,11 +7828,11 @@ cannot have changed since the precalculation. # define STORE_LC_NUMERIC_SET_TO_NEEDED_IN(in) \ STMT_START { \ - bool _in_lc_numeric = (in); \ + bool in_lc_numeric_ = (in); \ LC_NUMERIC_LOCK( \ - ( ( _in_lc_numeric && NOT_IN_NUMERIC_UNDERLYING_) \ - || (! _in_lc_numeric && NOT_IN_NUMERIC_STANDARD_))); \ - if (_in_lc_numeric) { \ + ( ( in_lc_numeric_ && NOT_IN_NUMERIC_UNDERLYING_) \ + || (! in_lc_numeric_ && NOT_IN_NUMERIC_STANDARD_))); \ + if (in_lc_numeric_) { \ if (NOT_IN_NUMERIC_UNDERLYING_) { \ Perl_set_numeric_underlying(aTHX_ __FILE__, __LINE__); \ restore_LC_NUMERIC_function_ \ From f2395eee3c465bac27d5267274557d0416b0e68d Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:38:38 -0600 Subject: [PATCH 38/87] Convert _to_uni_fold_flags to legal name --- embed.fnc | 2 +- embed.h | 2 +- pp.c | 2 +- proto.h | 10 +++++----- regcomp.c | 12 ++++++------ regexec.c | 4 ++-- utf8.c | 8 ++++---- utf8.h | 2 +- 8 files changed, 21 insertions(+), 21 deletions(-) diff --git a/embed.fnc b/embed.fnc index 23af64c288c9..456487078320 100644 --- a/embed.fnc +++ b/embed.fnc @@ -3657,7 +3657,7 @@ Xiop |Stack_off_t|TOPMARK Cmp |UV |to_uni_fold |UV c \ |NN U8 *p \ |NN STRLEN *lenp -Cp |UV |_to_uni_fold_flags \ +Cp |UV |to_uni_fold_flags_ \ |UV c \ |NN U8 *p \ |NN STRLEN *lenp \ diff --git a/embed.h b/embed.h index 4b2d0b8faf5a..873eac93e44f 100644 --- a/embed.h +++ b/embed.h @@ -122,7 +122,6 @@ # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) # define _is_utf8_perl_idstart(a,b) Perl__is_utf8_perl_idstart(aTHX_ a,b) -# define _to_uni_fold_flags(a,b,c,d) Perl__to_uni_fold_flags(aTHX_ a,b,c,d) # define _to_utf8_fold_flags(a,b,c,d,e) Perl__to_utf8_fold_flags(aTHX_ a,b,c,d,e) # define _to_utf8_lower_flags(a,b,c,d,e) Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e) # define _to_utf8_title_flags(a,b,c,d,e) Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e) @@ -809,6 +808,7 @@ # define sync_locale() Perl_sync_locale(aTHX) # define taint_env() Perl_taint_env(aTHX) # define taint_proper(a,b) Perl_taint_proper(aTHX_ a,b) +# define to_uni_fold_flags_(a,b,c,d) Perl_to_uni_fold_flags_(aTHX_ a,b,c,d) # define to_uni_lower(a,b,c) Perl_to_uni_lower(aTHX_ a,b,c) # define to_uni_title(a,b,c) Perl_to_uni_title(aTHX_ a,b,c) # define to_uni_upper(a,b,c) Perl_to_uni_upper(aTHX_ a,b,c) diff --git a/pp.c b/pp.c index 5b6b9e752364..e248f4e1013d 100644 --- a/pp.c +++ b/pp.c @@ -5242,7 +5242,7 @@ PP_wrapped(pp_fc, 1, 0) for (; s < send; s++) { STRLEN ulen; - _to_uni_fold_flags(*s, d, &ulen, flags); + to_uni_fold_flags_(*s, d, &ulen, flags); d += ulen; } break; diff --git a/proto.h b/proto.h index 2edc4d2bb807..5ed2b7bb2b19 100644 --- a/proto.h +++ b/proto.h @@ -124,11 +124,6 @@ Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ assert(p); assert(e) -PERL_CALLCONV UV -Perl__to_uni_fold_flags(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); -#define PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS \ - assert(p); assert(lenp) - PERL_CALLCONV UV Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags); #define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ @@ -5282,6 +5277,11 @@ Perl_tmps_grow_p(pTHX_ SSize_t ix); /* PERL_CALLCONV UV Perl_to_uni_fold(pTHX_ UV c, U8 *p, STRLEN *lenp); */ +PERL_CALLCONV UV +Perl_to_uni_fold_flags_(pTHX_ UV c, U8 *p, STRLEN *lenp, U8 flags); +#define PERL_ARGS_ASSERT_TO_UNI_FOLD_FLAGS_ \ + assert(p); assert(lenp) + PERL_CALLCONV UV Perl_to_uni_lower(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_LOWER \ diff --git a/regcomp.c b/regcomp.c index 6b74da9ee373..858fb86403f0 100644 --- a/regcomp.c +++ b/regcomp.c @@ -6848,7 +6848,7 @@ S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) UV folded; fold_anyway: - folded = _to_uni_fold_flags( + folded = to_uni_fold_flags_( ender, (U8 *) s, /* We have allocated extra space in 's' so can't run off the @@ -7262,7 +7262,7 @@ S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) Size_t added_len; /* Append the fold of ender */ - (void) _to_uni_fold_flags( + (void) to_uni_fold_flags_( ender, (U8 *) e, &added_len, @@ -10508,7 +10508,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, U8 foldbuf[UTF8_MAXBYTES_CASE+1]; STRLEN foldlen; - UV folded = _to_uni_fold_flags( + UV folded = to_uni_fold_flags_( value, foldbuf, &foldlen, @@ -10929,7 +10929,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, * rules hard-coded for it. First, get its fold. This is * the simple fold, as the multi-character folds have been * handled earlier and separated out */ - folded = _to_uni_fold_flags(j, foldbuf, &foldlen, + folded = to_uni_fold_flags_(j, foldbuf, &foldlen, (ASCII_FOLD_RESTRICTED) ? FOLD_FLAGS_NOMIX_ASCII : 0); @@ -11687,7 +11687,7 @@ S_optimize_regclass(pTHX_ Size_t foldlen; U8 foldbuf[UTF8_MAXBYTES_CASE]; - UV folded = _to_uni_fold_flags(lowest_cp, foldbuf, &foldlen, 0); + UV folded = to_uni_fold_flags_(lowest_cp, foldbuf, &foldlen, 0); U32 first_fold; const U32 * remaining_folds; Size_t folds_to_this_cp_count = _inverse_folds( @@ -11811,7 +11811,7 @@ S_optimize_regclass(pTHX_ /* This is a kludge to the special casing issues with this * ligature under /aa. FB05 should fold to FB06, but the call - * above to _to_uni_fold_flags() didn't find this, as it didn't + * above to to_uni_fold_flags_() didn't find this, as it didn't * use the /aa restriction in order to not miss other folds * that would be affected. This is the only instance likely to * ever be a problem in all of Unicode. So special case it. */ diff --git a/regexec.c b/regexec.c index 3eb8fe3a57cd..11cf015a5d61 100644 --- a/regexec.c +++ b/regexec.c @@ -4782,7 +4782,7 @@ S_setup_EXACTISH_ST(pTHX_ const regnode * const text_node, * pattern to be folded, which the input isn't required to * be in this case. So, just fold the single character, * and the result will be in the expected form. */ - _to_uni_fold_flags(multi_fold_from, mod_pat, &pat_len, + to_uni_fold_flags_(multi_fold_from, mod_pat, &pat_len, FOLD_FLAGS_FULL); pat = mod_pat; } @@ -4841,7 +4841,7 @@ S_setup_EXACTISH_ST(pTHX_ const regnode * const text_node, { /* We may have to canonicalize a multi-char fold, as in the UTF-8 * case */ - _to_uni_fold_flags(multi_fold_from, mod_pat, &pat_len, + to_uni_fold_flags_(multi_fold_from, mod_pat, &pat_len, FOLD_FLAGS_FULL); pat = mod_pat; } diff --git a/utf8.c b/utf8.c index 4d55c431557f..028fc9e3daa5 100644 --- a/utf8.c +++ b/utf8.c @@ -3807,7 +3807,7 @@ Perl__to_fold_latin1(const U8 c, U8* p, STRLEN *lenp, const unsigned int flags) } UV -Perl__to_uni_fold_flags(pTHX_ UV c, U8* p, STRLEN *lenp, U8 flags) +Perl_to_uni_fold_flags_(pTHX_ UV c, U8* p, STRLEN *lenp, U8 flags) { /* Not currently externally documented, and subject to change @@ -3818,7 +3818,7 @@ Perl__to_uni_fold_flags(pTHX_ UV c, U8* p, STRLEN *lenp, U8 flags) * FOLD_FLAGS_NOMIX_ASCII iff non-ASCII to ASCII folds are prohibited */ - PERL_ARGS_ASSERT__TO_UNI_FOLD_FLAGS; + PERL_ARGS_ASSERT_TO_UNI_FOLD_FLAGS_; if (flags & FOLD_FLAGS_LOCALE) { /* Treat a non-Turkic UTF-8 locale as not being in locale at all, @@ -5069,7 +5069,7 @@ Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, _toFOLD_utf8_flags(p1, e1, foldbuf1, &n1, flags_for_folder); } else { /* Not UTF-8, get UTF-8 fold */ - _to_uni_fold_flags(*p1, foldbuf1, &n1, flags_for_folder); + to_uni_fold_flags_(*p1, foldbuf1, &n1, flags_for_folder); } f1 = foldbuf1; } @@ -5107,7 +5107,7 @@ Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, _toFOLD_utf8_flags(p2, e2, foldbuf2, &n2, flags_for_folder); } else { - _to_uni_fold_flags(*p2, foldbuf2, &n2, flags_for_folder); + to_uni_fold_flags_(*p2, foldbuf2, &n2, flags_for_folder); } f2 = foldbuf2; } diff --git a/utf8.h b/utf8.h index 337d8c50ccdb..f4afd0c9be75 100644 --- a/utf8.h +++ b/utf8.h @@ -202,7 +202,7 @@ For details, see the description for L. #define utf8_to_utf16_reversed(p, d, bytelen, newlen) \ utf8_to_utf16_base(p, d, bytelen, newlen, 1, 0) -#define to_uni_fold(c, p, lenp) _to_uni_fold_flags(c, p, lenp, FOLD_FLAGS_FULL) +#define to_uni_fold(c, p, lenp) to_uni_fold_flags_(c, p, lenp, FOLD_FLAGS_FULL) #define foldEQ_utf8(s1, pe1, l1, u1, s2, pe2, l2, u2) \ foldEQ_utf8_flags(s1, pe1, l1, u1, s2, pe2, l2, u2, 0) From 197a325f59bc4cbd0afb8595a499175cf6d3e0e7 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:46:08 -0600 Subject: [PATCH 39/87] Convert _inverse_folds to legal name --- embed.fnc | 2 +- embed.h | 2 +- proto.h | 12 ++++++------ regcomp.c | 6 +++--- regcomp_study.c | 2 +- regexec.c | 2 +- utf8.c | 4 ++-- 7 files changed, 15 insertions(+), 15 deletions(-) diff --git a/embed.fnc b/embed.fnc index 456487078320..5473450a8915 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1665,7 +1665,7 @@ p |void |init_uniprops APRTdmp |char * |instr |NN const char *big \ |NN const char *little Adp |U32 |intro_my -ERXp |Size_t |_inverse_folds |const UV cp \ +ERXp |Size_t |inverse_folds_ |const UV cp \ |NN U32 *first_folds_to \ |NN const U32 **remaining_folds_to : Used in perly.y diff --git a/embed.h b/embed.h index 873eac93e44f..8e8043cbdc23 100644 --- a/embed.h +++ b/embed.h @@ -1798,7 +1798,6 @@ # endif # endif /* defined(PERL_CORE) */ # if defined(PERL_CORE) || defined(PERL_EXT) -# define _inverse_folds(a,b,c) Perl__inverse_folds(aTHX_ a,b,c) # define append_utf8_from_native_byte Perl_append_utf8_from_native_byte # define av_reify(a) Perl_av_reify(aTHX_ a) # define byte_dump_string_(a,b,c) Perl_byte_dump_string_(aTHX_ a,b,c) @@ -1811,6 +1810,7 @@ # define get_deprecated_property_msg Perl_get_deprecated_property_msg # define get_prop_definition(a) Perl_get_prop_definition(aTHX_ a) # define get_prop_values Perl_get_prop_values +# define inverse_folds_(a,b,c) Perl_inverse_folds_(aTHX_ a,b,c) # define load_charnames(a,b,c,d) Perl_load_charnames(aTHX_ a,b,c,d) # define mbtowc_(a,b,c) Perl_mbtowc_(aTHX_ a,b,c) # define mg_find_mglob(a) Perl_mg_find_mglob(aTHX_ a) diff --git a/proto.h b/proto.h index 5ed2b7bb2b19..dbe90849a684 100644 --- a/proto.h +++ b/proto.h @@ -88,9 +88,6 @@ Perl_Slab_Free(pTHX_ void *op); /* PERL_CALLCONV void Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ -#define PERL_ARGS_ASSERT__INVERSE_FOLDS \ - assert(first_folds_to); assert(remaining_folds_to) - PERL_CALLCONV bool Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) __attribute__warn_unused_result__; @@ -1840,6 +1837,9 @@ PERL_CALLCONV U32 Perl_intro_my(pTHX); #define PERL_ARGS_ASSERT_INTRO_MY +#define PERL_ARGS_ASSERT_INVERSE_FOLDS_ \ + assert(first_folds_to); assert(remaining_folds_to) + PERL_CALLCONV OP * Perl_invert(pTHX_ OP *cmd) __attribute__warn_unused_result__ @@ -6039,9 +6039,6 @@ S_should_warn_nl(const char *pv) # endif #endif /* defined(PERL_CORE) */ #if defined(PERL_CORE) || defined(PERL_EXT) -PERL_CALLCONV Size_t -Perl__inverse_folds(pTHX_ const UV cp, U32 *first_folds_to, const U32 **remaining_folds_to) - __attribute__warn_unused_result__; PERL_CALLCONV void Perl_av_reify(pTHX_ AV *av); PERL_CALLCONV const char * @@ -6077,6 +6074,9 @@ Perl_get_prop_definition(pTHX_ const int table_index) PERL_CALLCONV const char * const * Perl_get_prop_values(const int table_index) __attribute__warn_unused_result__; +PERL_CALLCONV Size_t +Perl_inverse_folds_(pTHX_ const UV cp, U32 *first_folds_to, const U32 **remaining_folds_to) + __attribute__warn_unused_result__; PERL_CALLCONV HV * Perl_load_charnames(pTHX_ SV *char_name, const char *context, const STRLEN context_len, const char **error_msg) __attribute__warn_unused_result__; diff --git a/regcomp.c b/regcomp.c index 858fb86403f0..1c6383518bc3 100644 --- a/regcomp.c +++ b/regcomp.c @@ -9330,7 +9330,7 @@ Perl_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** i *invlist = add_cp_to_invlist(*invlist, folded_cp); } - folds_count = _inverse_folds(folded_cp, &first_fold, + folds_count = inverse_folds_(folded_cp, &first_fold, &remaining_folds); if (folds_count == 0) { @@ -10937,7 +10937,7 @@ S_regclass(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth, /* Single character fold of above Latin1. Add everything * in its fold closure to the list that this node should * match. */ - folds_count = _inverse_folds(folded, &first_fold, + folds_count = inverse_folds_(folded, &first_fold, &remaining_folds); for (k = 0; k <= folds_count; k++) { UV c = (k == 0) /* First time through use itself */ @@ -11690,7 +11690,7 @@ S_optimize_regclass(pTHX_ UV folded = to_uni_fold_flags_(lowest_cp, foldbuf, &foldlen, 0); U32 first_fold; const U32 * remaining_folds; - Size_t folds_to_this_cp_count = _inverse_folds( + Size_t folds_to_this_cp_count = inverse_folds_( folded, &first_fold, &remaining_folds); diff --git a/regcomp_study.c b/regcomp_study.c index 7c6301707f8c..7c84834fee17 100644 --- a/regcomp_study.c +++ b/regcomp_study.c @@ -203,7 +203,7 @@ S_make_exactf_invlist(pTHX_ RExC_state_t *pRExC_state, regnode *node) /* ... plus all the things that fold to it, which are found in * PL_utf8_foldclosures */ - folds_count = _inverse_folds(fc, &first_fold, + folds_count = inverse_folds_(fc, &first_fold, &remaining_folds); for (k = 0; k < folds_count; k++) { UV c = (k == 0) ? first_fold : remaining_folds[k-1]; diff --git a/regexec.c b/regexec.c index 11cf015a5d61..bdc221a5cd58 100644 --- a/regexec.c +++ b/regexec.c @@ -4989,7 +4989,7 @@ S_setup_EXACTISH_ST(pTHX_ const regnode * const text_node, redo_multi: /* Look up what code points (besides itself) fold to 'folded'; * e.g., [ 'K', KELVIN_SIGN ] both fold to 'k'. */ - folds_to_count = _inverse_folds(folded, &first_fold_from, + folds_to_count = inverse_folds_(folded, &first_fold_from, &remaining_fold_froms); } diff --git a/utf8.c b/utf8.c index 028fc9e3daa5..a9e1c0ed0671 100644 --- a/utf8.c +++ b/utf8.c @@ -4085,7 +4085,7 @@ S__to_utf8_case(pTHX_ const UV original, const U8 *p, } Size_t -Perl__inverse_folds(pTHX_ const UV cp, U32 * first_folds_to, +Perl_inverse_folds_(pTHX_ const UV cp, U32 * first_folds_to, const U32 ** remaining_folds_to) { /* Returns the count of the number of code points that fold to the input @@ -4116,7 +4116,7 @@ Perl__inverse_folds(pTHX_ const UV cp, U32 * first_folds_to, SSize_t index = _invlist_search(PL_utf8_foldclosures, cp); I32 base = _Perl_IVCF_invmap[index]; - PERL_ARGS_ASSERT__INVERSE_FOLDS; + PERL_ARGS_ASSERT_INVERSE_FOLDS_; if (base == 0) { /* No fold */ *first_folds_to = 0; From a8205d22871abb30fd0527796058a499dc498ca4 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:50:52 -0600 Subject: [PATCH 40/87] Convert _toFOLD_utf8_flags to legal name --- handy.h | 4 ++-- pp.c | 2 +- regcomp_study.c | 2 +- regexec.c | 2 +- utf8.c | 8 ++++---- 5 files changed, 9 insertions(+), 9 deletions(-) diff --git a/handy.h b/handy.h index b2a8b8b90605..c347d75a2a17 100644 --- a/handy.h +++ b/handy.h @@ -2373,12 +2373,12 @@ END_EXTERN_C #define toUPPER_utf8(p,e,s,l) toUPPER_utf8_safe(p,e,s,l) /* For internal core use only, subject to change */ -#define _toFOLD_utf8_flags(p,e,s,l,f) _to_utf8_fold_flags (p,e,s,l,f) +#define toFOLD_utf8_flags_(p,e,s,l,f) _to_utf8_fold_flags (p,e,s,l,f) #define _toLOWER_utf8_flags(p,e,s,l,f) _to_utf8_lower_flags(p,e,s,l,f) #define _toTITLE_utf8_flags(p,e,s,l,f) _to_utf8_title_flags(p,e,s,l,f) #define _toUPPER_utf8_flags(p,e,s,l,f) _to_utf8_upper_flags(p,e,s,l,f) -#define toFOLD_utf8_safe(p,e,s,l) _toFOLD_utf8_flags(p,e,s,l, FOLD_FLAGS_FULL) +#define toFOLD_utf8_safe(p,e,s,l) toFOLD_utf8_flags_(p,e,s,l, FOLD_FLAGS_FULL) #define toLOWER_utf8_safe(p,e,s,l) _toLOWER_utf8_flags(p,e,s,l, 0) #define toTITLE_utf8_safe(p,e,s,l) _toTITLE_utf8_flags(p,e,s,l, 0) #define toUPPER_utf8_safe(p,e,s,l) _toUPPER_utf8_flags(p,e,s,l, 0) diff --git a/pp.c b/pp.c index e248f4e1013d..7bc76a728044 100644 --- a/pp.c +++ b/pp.c @@ -5138,7 +5138,7 @@ PP_wrapped(pp_fc, 1, 0) const STRLEN this_len = UTF8SKIP(s); STRLEN ulen; - _toFOLD_utf8_flags(s, send, tmpbuf, &ulen, flags); + toFOLD_utf8_flags_(s, send, tmpbuf, &ulen, flags); if (ulen > this_len && (SvLEN(dest) < (min += ulen - this_len))) { const UV o = d - (U8*)SvPVX_const(dest); diff --git a/regcomp_study.c b/regcomp_study.c index 7c84834fee17..5fd1c901c50d 100644 --- a/regcomp_study.c +++ b/regcomp_study.c @@ -1311,7 +1311,7 @@ Perl_join_exact(pTHX_ RExC_state_t *pRExC_state, regnode *scan, } else { STRLEN len; - _toFOLD_utf8_flags(s, s_end, d, &len, FOLD_FLAGS_FULL); + toFOLD_utf8_flags_(s, s_end, d, &len, FOLD_FLAGS_FULL); d += len; } s += s_len; diff --git a/regexec.c b/regexec.c index bdc221a5cd58..4a3302505b26 100644 --- a/regexec.c +++ b/regexec.c @@ -1828,7 +1828,7 @@ STMT_START { \ uscan += len; \ len = 0; \ } else { \ - uvc = _toFOLD_utf8_flags( (const U8*) uc, uc_end, foldbuf, \ + uvc = toFOLD_utf8_flags_( (const U8*) uc, uc_end, foldbuf, \ &foldlen, flags); \ len = UTF8_SAFE_SKIP(uc, uc_end); \ skiplen = UVCHR_SKIP( uvc ); \ diff --git a/utf8.c b/utf8.c index a9e1c0ed0671..eab8a5cbfc9f 100644 --- a/utf8.c +++ b/utf8.c @@ -3841,13 +3841,13 @@ Perl_to_uni_fold_flags_(pTHX_ UV c, U8* p, STRLEN *lenp, U8 flags) if ( ! (flags & (FOLD_FLAGS_LOCALE|FOLD_FLAGS_NOMIX_ASCII))) { return CALL_FOLD_CASE(c, NULL, p, lenp, flags & FOLD_FLAGS_FULL); } - else { /* Otherwise, _toFOLD_utf8_flags has the intelligence to deal with + else { /* Otherwise, toFOLD_utf8_flags_ has the intelligence to deal with the special flags. */ U8 utf8_c[UTF8_MAXBYTES + 1]; needs_full_generality: uv_to_utf8(utf8_c, c); - return _toFOLD_utf8_flags(utf8_c, utf8_c + C_ARRAY_LENGTH(utf8_c), + return toFOLD_utf8_flags_(utf8_c, utf8_c + C_ARRAY_LENGTH(utf8_c), p, lenp, flags); } } @@ -5066,7 +5066,7 @@ Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, *foldbuf1 = toFOLD(*p1); } else if (u1) { - _toFOLD_utf8_flags(p1, e1, foldbuf1, &n1, flags_for_folder); + toFOLD_utf8_flags_(p1, e1, foldbuf1, &n1, flags_for_folder); } else { /* Not UTF-8, get UTF-8 fold */ to_uni_fold_flags_(*p1, foldbuf1, &n1, flags_for_folder); @@ -5104,7 +5104,7 @@ Perl_foldEQ_utf8_flags(pTHX_ const char *s1, char **pe1, UV l1, bool u1, *foldbuf2 = toFOLD(*p2); } else if (u2) { - _toFOLD_utf8_flags(p2, e2, foldbuf2, &n2, flags_for_folder); + toFOLD_utf8_flags_(p2, e2, foldbuf2, &n2, flags_for_folder); } else { to_uni_fold_flags_(*p2, foldbuf2, &n2, flags_for_folder); From 89971f3e6736b5d677102ac18b7251e395c54cbb Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 15:53:45 -0600 Subject: [PATCH 41/87] Convert _tofold_latin1 to legal name --- embed.fnc | 2 +- embed.h | 2 +- proto.h | 4 ++-- regcomp.c | 2 +- regexec.c | 2 +- utf8.c | 8 ++++---- 6 files changed, 10 insertions(+), 10 deletions(-) diff --git a/embed.fnc b/embed.fnc index 5473450a8915..ea96d944a754 100644 --- a/embed.fnc +++ b/embed.fnc @@ -5602,7 +5602,7 @@ ERp |bool |is_grapheme |NN const U8 *strbeg \ #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_UTF8_C) -ETXp |UV |_to_fold_latin1|const U8 c \ +ETXp |UV |to_fold_latin1_|const U8 c \ |NN U8 *p \ |NN STRLEN *lenp \ |const unsigned int flags diff --git a/embed.h b/embed.h index 8e8043cbdc23..5cab0ddfdc23 100644 --- a/embed.h +++ b/embed.h @@ -1992,7 +1992,7 @@ # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_UTF8_C) -# define _to_fold_latin1 Perl__to_fold_latin1 +# define to_fold_latin1_ Perl_to_fold_latin1_ # endif # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_TOKE_C) # define regcurly Perl_regcurly diff --git a/proto.h b/proto.h index dbe90849a684..3307db100821 100644 --- a/proto.h +++ b/proto.h @@ -6216,7 +6216,7 @@ Perl_is_grapheme(pTHX_ const U8 *strbeg, const U8 *s, const U8 *strend, const UV # if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_UTF8_C) PERL_CALLCONV UV -Perl__to_fold_latin1(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); +Perl_to_fold_latin1_(const U8 c, U8 *p, STRLEN *lenp, const unsigned int flags); # endif # if defined(PERL_IN_REGCOMP_DEBUG_C) && defined(DEBUGGING) STATIC U8 @@ -8652,7 +8652,7 @@ Perl_populate_invlist_from_bitmap(pTHX_ const U8 *bitmap, const Size_t bitmap_le #endif #if defined(PERL_IN_REGCOMP_C) || defined(PERL_IN_REGEXEC_C) || \ defined(PERL_IN_UTF8_C) -# define PERL_ARGS_ASSERT__TO_FOLD_LATIN1 \ +# define PERL_ARGS_ASSERT_TO_FOLD_LATIN1_ \ assert(p); assert(lenp) #endif diff --git a/regcomp.c b/regcomp.c index 1c6383518bc3..bde026f6e6ee 100644 --- a/regcomp.c +++ b/regcomp.c @@ -9323,7 +9323,7 @@ Perl_add_above_Latin1_folds(pTHX_ RExC_state_t *pRExC_state, const U8 cp, SV** i else { U8 dummy_fold[UTF8_MAXBYTES_CASE+1]; Size_t dummy_len; - folded_cp = _to_fold_latin1(cp, dummy_fold, &dummy_len, 0); + folded_cp = to_fold_latin1_(cp, dummy_fold, &dummy_len, 0); } if (folded_cp > 255) { diff --git a/regexec.c b/regexec.c index 4a3302505b26..e586d6f53502 100644 --- a/regexec.c +++ b/regexec.c @@ -1853,7 +1853,7 @@ STMT_START { \ len = 0; \ } else { \ len = 1; \ - uvc = _to_fold_latin1( (U8) *uc, foldbuf, &foldlen, flags); \ + uvc = to_fold_latin1_( (U8) *uc, foldbuf, &foldlen, flags); \ skiplen = UVCHR_SKIP( uvc ); \ foldlen -= skiplen; \ uscan = foldbuf + skiplen; \ diff --git a/utf8.c b/utf8.c index eab8a5cbfc9f..0de74a1c9b8c 100644 --- a/utf8.c +++ b/utf8.c @@ -3747,7 +3747,7 @@ Perl_to_uni_lower(pTHX_ UV c, U8* p, STRLEN *lenp) } UV -Perl__to_fold_latin1(const U8 c, U8* p, STRLEN *lenp, const unsigned int flags) +Perl_to_fold_latin1_(const U8 c, U8* p, STRLEN *lenp, const unsigned int flags) { /* Corresponds to to_lower_latin1(); bits meanings: * FOLD_FLAGS_NOMIX_ASCII iff non-ASCII to ASCII folds are prohibited @@ -3758,7 +3758,7 @@ Perl__to_fold_latin1(const U8 c, U8* p, STRLEN *lenp, const unsigned int flags) UV converted; - PERL_ARGS_ASSERT__TO_FOLD_LATIN1; + PERL_ARGS_ASSERT_TO_FOLD_LATIN1_; assert (! (flags & FOLD_FLAGS_LOCALE)); @@ -3833,7 +3833,7 @@ Perl_to_uni_fold_flags_(pTHX_ UV c, U8* p, STRLEN *lenp, U8 flags) } if (c < 256) { - return _to_fold_latin1((U8) c, p, lenp, + return to_fold_latin1_((U8) c, p, lenp, flags & (FOLD_FLAGS_FULL | FOLD_FLAGS_NOMIX_ASCII)); } @@ -4504,7 +4504,7 @@ Perl__to_utf8_fold_flags(pTHX_ const U8 *p, assert(p != ustrp); /* Otherwise overwrites */ - CASE_CHANGE_BODY_START(FOLD_FLAGS_LOCALE, tolower, _to_fold_latin1, + CASE_CHANGE_BODY_START(FOLD_FLAGS_LOCALE, tolower, to_fold_latin1_, ((flags) & (FOLD_FLAGS_FULL | FOLD_FLAGS_NOMIX_ASCII)), turkic_fc); From a8bd9295c844424aa9f659f0f7e4d3949fa3fb93 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Fri, 15 Aug 2025 09:59:35 -0600 Subject: [PATCH 42/87] onvert _to_utf8_fold_flags to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 2 +- proto.h | 10 +++++----- regcomp.c | 4 ++-- regexec.c | 2 +- utf8.c | 6 +++--- 7 files changed, 14 insertions(+), 14 deletions(-) diff --git a/embed.fnc b/embed.fnc index ea96d944a754..0b223de471a3 100644 --- a/embed.fnc +++ b/embed.fnc @@ -3671,7 +3671,7 @@ Cp |UV |to_uni_title |UV c \ Cp |UV |to_uni_upper |UV c \ |NN U8 *p \ |NN STRLEN *lenp -Cp |UV |_to_utf8_fold_flags \ +Cp |UV |to_utf8_fold_flags_ \ |NN const U8 *p \ |NULLOK const U8 *e \ |NN U8 *ustrp \ diff --git a/embed.h b/embed.h index 5cab0ddfdc23..e3f1f84c84d6 100644 --- a/embed.h +++ b/embed.h @@ -122,7 +122,6 @@ # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) # define _is_utf8_perl_idstart(a,b) Perl__is_utf8_perl_idstart(aTHX_ a,b) -# define _to_utf8_fold_flags(a,b,c,d,e) Perl__to_utf8_fold_flags(aTHX_ a,b,c,d,e) # define _to_utf8_lower_flags(a,b,c,d,e) Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e) # define _to_utf8_title_flags(a,b,c,d,e) Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e) # define _to_utf8_upper_flags(a,b,c,d,e) Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e) @@ -812,6 +811,7 @@ # define to_uni_lower(a,b,c) Perl_to_uni_lower(aTHX_ a,b,c) # define to_uni_title(a,b,c) Perl_to_uni_title(aTHX_ a,b,c) # define to_uni_upper(a,b,c) Perl_to_uni_upper(aTHX_ a,b,c) +# define to_utf8_fold_flags_(a,b,c,d,e) Perl_to_utf8_fold_flags_(aTHX_ a,b,c,d,e) # define uiv_2buf Perl_uiv_2buf # define unpackstring(a,b,c,d,e) Perl_unpackstring(aTHX_ a,b,c,d,e) # define unshare_hek(a) Perl_unshare_hek(aTHX_ a) diff --git a/handy.h b/handy.h index c347d75a2a17..ff57a4171e42 100644 --- a/handy.h +++ b/handy.h @@ -2373,7 +2373,7 @@ END_EXTERN_C #define toUPPER_utf8(p,e,s,l) toUPPER_utf8_safe(p,e,s,l) /* For internal core use only, subject to change */ -#define toFOLD_utf8_flags_(p,e,s,l,f) _to_utf8_fold_flags (p,e,s,l,f) +#define toFOLD_utf8_flags_(p,e,s,l,f) to_utf8_fold_flags_(p,e,s,l,f) #define _toLOWER_utf8_flags(p,e,s,l,f) _to_utf8_lower_flags(p,e,s,l,f) #define _toTITLE_utf8_flags(p,e,s,l,f) _to_utf8_title_flags(p,e,s,l,f) #define _toUPPER_utf8_flags(p,e,s,l,f) _to_utf8_upper_flags(p,e,s,l,f) diff --git a/proto.h b/proto.h index 3307db100821..40f5e7912d8f 100644 --- a/proto.h +++ b/proto.h @@ -121,11 +121,6 @@ Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ assert(p); assert(e) -PERL_CALLCONV UV -Perl__to_utf8_fold_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags); -#define PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS \ - assert(p); assert(ustrp) - PERL_CALLCONV UV Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ @@ -5297,6 +5292,11 @@ Perl_to_uni_upper(pTHX_ UV c, U8 *p, STRLEN *lenp); #define PERL_ARGS_ASSERT_TO_UNI_UPPER \ assert(p); assert(lenp) +PERL_CALLCONV UV +Perl_to_utf8_fold_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, U8 flags); +#define PERL_ARGS_ASSERT_TO_UTF8_FOLD_FLAGS_ \ + assert(p); assert(ustrp) + PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN diff --git a/regcomp.c b/regcomp.c index bde026f6e6ee..700bdd3c2b4b 100644 --- a/regcomp.c +++ b/regcomp.c @@ -7156,7 +7156,7 @@ S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) if (UTF) { Size_t added_len; - (void) _to_utf8_fold_flags((U8 *) redo_p, + (void) to_utf8_fold_flags_((U8 *) redo_p, (U8 *) RExC_end, (U8 *) redo_e, &added_len, @@ -7305,7 +7305,7 @@ S_regatom(pTHX_ RExC_state_t *pRExC_state, I32 *flagp, U32 depth) * 'e' (having deliberately reserved enough space * for this eventuality) and drop down to check if * the three actually do form a folded sequence */ - (void) _to_utf8_fold_flags( + (void) to_utf8_fold_flags_( (U8 *) p, (U8 *) RExC_end, (U8 *) e, &added_len, diff --git a/regexec.c b/regexec.c index e586d6f53502..7a58e32f41fb 100644 --- a/regexec.c +++ b/regexec.c @@ -4827,7 +4827,7 @@ S_setup_EXACTISH_ST(pTHX_ const regnode * const text_node, utf8_pat = false; } else { /* Code point above 255, or needs special handling */ - _to_utf8_fold_flags(pat, pat + pat_len, + to_utf8_fold_flags_(pat, pat + pat_len, mod_pat, &pat_len, FOLD_FLAGS_FULL|FOLD_FLAGS_LOCALE); pat = mod_pat; diff --git a/utf8.c b/utf8.c index 0de74a1c9b8c..d49653bee3e5 100644 --- a/utf8.c +++ b/utf8.c @@ -4489,15 +4489,15 @@ Perl__to_utf8_lower_flags(pTHX_ const U8 *p, */ UV -Perl__to_utf8_fold_flags(pTHX_ const U8 *p, +Perl_to_utf8_fold_flags_(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, U8 flags) { - UV result; + PERL_ARGS_ASSERT_TO_UTF8_FOLD_FLAGS_; - PERL_ARGS_ASSERT__TO_UTF8_FOLD_FLAGS; + UV result; /* These are mutually exclusive */ assert (! ((flags & FOLD_FLAGS_LOCALE) && (flags & FOLD_FLAGS_NOMIX_ASCII))); From 4a9958c2e602e6cf70467a31156993c065317a75 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Fri, 15 Aug 2025 10:02:17 -0600 Subject: [PATCH 43/87] Convert _to_utf8_lower_flags to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 2 +- proto.h | 10 +++++----- utf8.c | 6 +++--- 5 files changed, 11 insertions(+), 11 deletions(-) diff --git a/embed.fnc b/embed.fnc index 0b223de471a3..5b1b29222485 100644 --- a/embed.fnc +++ b/embed.fnc @@ -3678,7 +3678,7 @@ Cp |UV |to_utf8_fold_flags_ \ |NULLOK STRLEN *lenp \ |U8 flags -Cp |UV |_to_utf8_lower_flags \ +Cp |UV |to_utf8_lower_flags_ \ |NN const U8 *p \ |NULLOK const U8 *e \ |NN U8 *ustrp \ diff --git a/embed.h b/embed.h index e3f1f84c84d6..3fdeac2ed890 100644 --- a/embed.h +++ b/embed.h @@ -122,7 +122,6 @@ # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) # define _is_utf8_perl_idstart(a,b) Perl__is_utf8_perl_idstart(aTHX_ a,b) -# define _to_utf8_lower_flags(a,b,c,d,e) Perl__to_utf8_lower_flags(aTHX_ a,b,c,d,e) # define _to_utf8_title_flags(a,b,c,d,e) Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e) # define _to_utf8_upper_flags(a,b,c,d,e) Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e) # define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) @@ -812,6 +811,7 @@ # define to_uni_title(a,b,c) Perl_to_uni_title(aTHX_ a,b,c) # define to_uni_upper(a,b,c) Perl_to_uni_upper(aTHX_ a,b,c) # define to_utf8_fold_flags_(a,b,c,d,e) Perl_to_utf8_fold_flags_(aTHX_ a,b,c,d,e) +# define to_utf8_lower_flags_(a,b,c,d,e) Perl_to_utf8_lower_flags_(aTHX_ a,b,c,d,e) # define uiv_2buf Perl_uiv_2buf # define unpackstring(a,b,c,d,e) Perl_unpackstring(aTHX_ a,b,c,d,e) # define unshare_hek(a) Perl_unshare_hek(aTHX_ a) diff --git a/handy.h b/handy.h index ff57a4171e42..58eafe9bc422 100644 --- a/handy.h +++ b/handy.h @@ -2374,7 +2374,7 @@ END_EXTERN_C /* For internal core use only, subject to change */ #define toFOLD_utf8_flags_(p,e,s,l,f) to_utf8_fold_flags_(p,e,s,l,f) -#define _toLOWER_utf8_flags(p,e,s,l,f) _to_utf8_lower_flags(p,e,s,l,f) +#define _toLOWER_utf8_flags(p,e,s,l,f) to_utf8_lower_flags_(p,e,s,l,f) #define _toTITLE_utf8_flags(p,e,s,l,f) _to_utf8_title_flags(p,e,s,l,f) #define _toUPPER_utf8_flags(p,e,s,l,f) _to_utf8_upper_flags(p,e,s,l,f) diff --git a/proto.h b/proto.h index 40f5e7912d8f..e63393953c17 100644 --- a/proto.h +++ b/proto.h @@ -121,11 +121,6 @@ Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ assert(p); assert(e) -PERL_CALLCONV UV -Perl__to_utf8_lower_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); -#define PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS \ - assert(p); assert(ustrp) - PERL_CALLCONV UV Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ @@ -5297,6 +5292,11 @@ Perl_to_utf8_fold_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp #define PERL_ARGS_ASSERT_TO_UTF8_FOLD_FLAGS_ \ assert(p); assert(ustrp) +PERL_CALLCONV UV +Perl_to_utf8_lower_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); +#define PERL_ARGS_ASSERT_TO_UTF8_LOWER_FLAGS_ \ + assert(p); assert(ustrp) + PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN diff --git a/utf8.c b/utf8.c index d49653bee3e5..6c6d91e27e6b 100644 --- a/utf8.c +++ b/utf8.c @@ -4463,15 +4463,15 @@ Perl__to_utf8_title_flags(pTHX_ const U8 *p, */ UV -Perl__to_utf8_lower_flags(pTHX_ const U8 *p, +Perl_to_utf8_lower_flags_(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags) { - UV result; + PERL_ARGS_ASSERT_TO_UTF8_LOWER_FLAGS_; - PERL_ARGS_ASSERT__TO_UTF8_LOWER_FLAGS; + UV result; CASE_CHANGE_BODY_START(~0, tolower, to_lower_latin1, 0 /* 0 is dummy */, turkic_lc); From 9b55195eda0946843bfbac41899fccfaa74c2632 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:02:49 -0600 Subject: [PATCH 44/87] Convert _to_upper_title_latin1 to legal name --- embed.fnc | 2 +- embed.h | 2 +- pp.c | 6 +++--- proto.h | 4 ++-- utf8.c | 14 +++++++------- 5 files changed, 14 insertions(+), 14 deletions(-) diff --git a/embed.fnc b/embed.fnc index 5b1b29222485..11f7b82f588b 100644 --- a/embed.fnc +++ b/embed.fnc @@ -5138,7 +5138,7 @@ ETi |const char *|get_regex_charset_name \ |NN STRLEN * const lenp #endif #if defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C) -p |UV |_to_upper_title_latin1 \ +p |UV |to_upper_title_latin1_ \ |const U8 c \ |NN U8 *p \ |NN STRLEN *lenp \ diff --git a/embed.h b/embed.h index 3fdeac2ed890..8029dd4908c0 100644 --- a/embed.h +++ b/embed.h @@ -1579,7 +1579,7 @@ # define lossless_NV_to_IV S_lossless_NV_to_IV # endif # if defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C) -# define _to_upper_title_latin1(a,b,c,d) Perl__to_upper_title_latin1(aTHX_ a,b,c,d) +# define to_upper_title_latin1_(a,b,c,d) Perl_to_upper_title_latin1_(aTHX_ a,b,c,d) # endif # if defined(PERL_IN_PP_CTL_C) # define check_type_and_open(a) S_check_type_and_open(aTHX_ a) diff --git a/pp.c b/pp.c index 7bc76a728044..6725f5582984 100644 --- a/pp.c +++ b/pp.c @@ -4271,7 +4271,7 @@ PP_wrapped(pp_ucfirst, 1, 0) do_uni_rules: #endif - title_ord = _to_upper_title_latin1(*s, tmpbuf, &tculen, 's'); + title_ord = to_upper_title_latin1_(*s, tmpbuf, &tculen, 's'); if (tculen > 1) { assert(tculen == 2); @@ -4735,7 +4735,7 @@ PP_wrapped(pp_uc, 1, 0) *d++ = UTF8_TWO_BYTE_LO(LATIN_CAPITAL_LETTER_I_WITH_DOT_ABOVE); } else { - (void) _to_upper_title_latin1(*s, d, &len, 'S'); + (void) to_upper_title_latin1_(*s, d, &len, 'S'); d += len; } } @@ -4743,7 +4743,7 @@ PP_wrapped(pp_uc, 1, 0) else #endif for (; s < send; s++) { - (void) _to_upper_title_latin1(*s, d, &len, 'S'); + (void) to_upper_title_latin1_(*s, d, &len, 'S'); d += len; } diff --git a/proto.h b/proto.h index e63393953c17..458166daee31 100644 --- a/proto.h +++ b/proto.h @@ -7886,9 +7886,9 @@ Perl_softref2xv(pTHX_ SV * const sv, const char * const what, const svtype type) #endif #if defined(PERL_IN_PP_C) || defined(PERL_IN_UTF8_C) PERL_CALLCONV UV -Perl__to_upper_title_latin1(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) +Perl_to_upper_title_latin1_(pTHX_ const U8 c, U8 *p, STRLEN *lenp, const char S_or_s) __attribute__visibility__("hidden"); -# define PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1 \ +# define PERL_ARGS_ASSERT_TO_UPPER_TITLE_LATIN1_ \ assert(p); assert(lenp) #endif diff --git a/utf8.c b/utf8.c index 6c6d91e27e6b..3bc66e7b8ac7 100644 --- a/utf8.c +++ b/utf8.c @@ -3555,9 +3555,11 @@ Perl__is_uni_perl_idstart(pTHX_ UV c) } UV -Perl__to_upper_title_latin1(pTHX_ const U8 c, U8* p, STRLEN *lenp, +Perl_to_upper_title_latin1_(pTHX_ const U8 c, U8* p, STRLEN *lenp, const char S_or_s) { + PERL_ARGS_ASSERT_TO_UPPER_TITLE_LATIN1_; + /* We have the latin1-range values compiled into the core, so just use * those, converting the result to UTF-8. The only difference between upper * and title case in this range is that LATIN_SMALL_LETTER_SHARP_S is @@ -3566,8 +3568,6 @@ Perl__to_upper_title_latin1(pTHX_ const U8 c, U8* p, STRLEN *lenp, UV converted = toUPPER_LATIN1_MOD(c); - PERL_ARGS_ASSERT__TO_UPPER_TITLE_LATIN1; - assert(S_or_s == 'S' || S_or_s == 's'); if (UVCHR_IS_INVARIANT(converted)) { /* No difference between the two for @@ -3689,7 +3689,7 @@ Perl_to_uni_upper(pTHX_ UV c, U8* p, STRLEN *lenp) PERL_ARGS_ASSERT_TO_UNI_UPPER; if (c < 256) { - return _to_upper_title_latin1((U8) c, p, lenp, 'S'); + return to_upper_title_latin1_((U8) c, p, lenp, 'S'); } return CALL_UPPER_CASE(c, NULL, p, lenp); @@ -3701,7 +3701,7 @@ Perl_to_uni_title(pTHX_ UV c, U8* p, STRLEN *lenp) PERL_ARGS_ASSERT_TO_UNI_TITLE; if (c < 256) { - return _to_upper_title_latin1((U8) c, p, lenp, 's'); + return to_upper_title_latin1_((U8) c, p, lenp, 's'); } return CALL_TITLE_CASE(c, NULL, p, lenp); @@ -4429,7 +4429,7 @@ Perl__to_utf8_upper_flags(pTHX_ const U8 *p, /* ~0 makes anything non-zero in 'flags' mean we are using locale rules */ /* 2nd char of uc(U+DF) is 'S' */ - CASE_CHANGE_BODY_START(~0, toupper, _to_upper_title_latin1, 'S', + CASE_CHANGE_BODY_START(~0, toupper, to_upper_title_latin1_, 'S', turkic_uc); CASE_CHANGE_BODY_END (~0, CALL_UPPER_CASE); } @@ -4452,7 +4452,7 @@ Perl__to_utf8_title_flags(pTHX_ const U8 *p, PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS; /* 2nd char of ucfirst(U+DF) is 's' */ - CASE_CHANGE_BODY_START(~0, toupper, _to_upper_title_latin1, 's', + CASE_CHANGE_BODY_START(~0, toupper, to_upper_title_latin1_, 's', turkic_uc); CASE_CHANGE_BODY_END (~0, CALL_TITLE_CASE); } From 02158ac947d069452afda1fdd6d9c2f7a5c3b8ba Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:05:52 -0600 Subject: [PATCH 45/87] Convert _to_utf8_title_flags to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 2 +- proto.h | 10 +++++----- utf8.c | 6 +++--- 5 files changed, 11 insertions(+), 11 deletions(-) diff --git a/embed.fnc b/embed.fnc index 11f7b82f588b..598a3a687eac 100644 --- a/embed.fnc +++ b/embed.fnc @@ -3684,7 +3684,7 @@ Cp |UV |to_utf8_lower_flags_ \ |NN U8 *ustrp \ |NULLOK STRLEN *lenp \ |bool flags -Cp |UV |_to_utf8_title_flags \ +Cp |UV |to_utf8_title_flags_ \ |NN const U8 *p \ |NULLOK const U8 *e \ |NN U8 *ustrp \ diff --git a/embed.h b/embed.h index 8029dd4908c0..58bfa2cb0474 100644 --- a/embed.h +++ b/embed.h @@ -122,7 +122,6 @@ # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) # define _is_utf8_perl_idstart(a,b) Perl__is_utf8_perl_idstart(aTHX_ a,b) -# define _to_utf8_title_flags(a,b,c,d,e) Perl__to_utf8_title_flags(aTHX_ a,b,c,d,e) # define _to_utf8_upper_flags(a,b,c,d,e) Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e) # define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) # define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b) @@ -812,6 +811,7 @@ # define to_uni_upper(a,b,c) Perl_to_uni_upper(aTHX_ a,b,c) # define to_utf8_fold_flags_(a,b,c,d,e) Perl_to_utf8_fold_flags_(aTHX_ a,b,c,d,e) # define to_utf8_lower_flags_(a,b,c,d,e) Perl_to_utf8_lower_flags_(aTHX_ a,b,c,d,e) +# define to_utf8_title_flags_(a,b,c,d,e) Perl_to_utf8_title_flags_(aTHX_ a,b,c,d,e) # define uiv_2buf Perl_uiv_2buf # define unpackstring(a,b,c,d,e) Perl_unpackstring(aTHX_ a,b,c,d,e) # define unshare_hek(a) Perl_unshare_hek(aTHX_ a) diff --git a/handy.h b/handy.h index 58eafe9bc422..0e8bae61faaa 100644 --- a/handy.h +++ b/handy.h @@ -2375,7 +2375,7 @@ END_EXTERN_C /* For internal core use only, subject to change */ #define toFOLD_utf8_flags_(p,e,s,l,f) to_utf8_fold_flags_(p,e,s,l,f) #define _toLOWER_utf8_flags(p,e,s,l,f) to_utf8_lower_flags_(p,e,s,l,f) -#define _toTITLE_utf8_flags(p,e,s,l,f) _to_utf8_title_flags(p,e,s,l,f) +#define _toTITLE_utf8_flags(p,e,s,l,f) to_utf8_title_flags_(p,e,s,l,f) #define _toUPPER_utf8_flags(p,e,s,l,f) _to_utf8_upper_flags(p,e,s,l,f) #define toFOLD_utf8_safe(p,e,s,l) toFOLD_utf8_flags_(p,e,s,l, FOLD_FLAGS_FULL) diff --git a/proto.h b/proto.h index 458166daee31..0359a4d6a9e7 100644 --- a/proto.h +++ b/proto.h @@ -121,11 +121,6 @@ Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ assert(p); assert(e) -PERL_CALLCONV UV -Perl__to_utf8_title_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); -#define PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS \ - assert(p); assert(ustrp) - PERL_CALLCONV UV Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); #define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ @@ -5297,6 +5292,11 @@ Perl_to_utf8_lower_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *len #define PERL_ARGS_ASSERT_TO_UTF8_LOWER_FLAGS_ \ assert(p); assert(ustrp) +PERL_CALLCONV UV +Perl_to_utf8_title_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); +#define PERL_ARGS_ASSERT_TO_UTF8_TITLE_FLAGS_ \ + assert(p); assert(ustrp) + PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN diff --git a/utf8.c b/utf8.c index 3bc66e7b8ac7..9ac9fb8929ee 100644 --- a/utf8.c +++ b/utf8.c @@ -4441,15 +4441,15 @@ Perl__to_utf8_upper_flags(pTHX_ const U8 *p, */ UV -Perl__to_utf8_title_flags(pTHX_ const U8 *p, +Perl_to_utf8_title_flags_(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags) { - UV result; + PERL_ARGS_ASSERT_TO_UTF8_TITLE_FLAGS_; - PERL_ARGS_ASSERT__TO_UTF8_TITLE_FLAGS; + UV result; /* 2nd char of ucfirst(U+DF) is 's' */ CASE_CHANGE_BODY_START(~0, toupper, to_upper_title_latin1_, 's', From 90faf474cb40128bf7f0e80ccc0ae486ae99848b Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:08:34 -0600 Subject: [PATCH 46/87] Convert _to_utf8_upper_flags to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 2 +- proto.h | 10 +++++----- utf8.c | 6 +++--- 5 files changed, 11 insertions(+), 11 deletions(-) diff --git a/embed.fnc b/embed.fnc index 598a3a687eac..ef1099b1e940 100644 --- a/embed.fnc +++ b/embed.fnc @@ -3690,7 +3690,7 @@ Cp |UV |to_utf8_title_flags_ \ |NN U8 *ustrp \ |NULLOK STRLEN *lenp \ |bool flags -Cp |UV |_to_utf8_upper_flags \ +Cp |UV |to_utf8_upper_flags_ \ |NN const U8 *p \ |NULLOK const U8 *e \ |NN U8 *ustrp \ diff --git a/embed.h b/embed.h index 58bfa2cb0474..2ae958818ea9 100644 --- a/embed.h +++ b/embed.h @@ -122,7 +122,6 @@ # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) # define _is_utf8_perl_idstart(a,b) Perl__is_utf8_perl_idstart(aTHX_ a,b) -# define _to_utf8_upper_flags(a,b,c,d,e) Perl__to_utf8_upper_flags(aTHX_ a,b,c,d,e) # define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) # define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b) # define apply_attrs_string(a,b,c,d) Perl_apply_attrs_string(aTHX_ a,b,c,d) @@ -812,6 +811,7 @@ # define to_utf8_fold_flags_(a,b,c,d,e) Perl_to_utf8_fold_flags_(aTHX_ a,b,c,d,e) # define to_utf8_lower_flags_(a,b,c,d,e) Perl_to_utf8_lower_flags_(aTHX_ a,b,c,d,e) # define to_utf8_title_flags_(a,b,c,d,e) Perl_to_utf8_title_flags_(aTHX_ a,b,c,d,e) +# define to_utf8_upper_flags_(a,b,c,d,e) Perl_to_utf8_upper_flags_(aTHX_ a,b,c,d,e) # define uiv_2buf Perl_uiv_2buf # define unpackstring(a,b,c,d,e) Perl_unpackstring(aTHX_ a,b,c,d,e) # define unshare_hek(a) Perl_unshare_hek(aTHX_ a) diff --git a/handy.h b/handy.h index 0e8bae61faaa..128eebc7e9db 100644 --- a/handy.h +++ b/handy.h @@ -2376,7 +2376,7 @@ END_EXTERN_C #define toFOLD_utf8_flags_(p,e,s,l,f) to_utf8_fold_flags_(p,e,s,l,f) #define _toLOWER_utf8_flags(p,e,s,l,f) to_utf8_lower_flags_(p,e,s,l,f) #define _toTITLE_utf8_flags(p,e,s,l,f) to_utf8_title_flags_(p,e,s,l,f) -#define _toUPPER_utf8_flags(p,e,s,l,f) _to_utf8_upper_flags(p,e,s,l,f) +#define _toUPPER_utf8_flags(p,e,s,l,f) to_utf8_upper_flags_(p,e,s,l,f) #define toFOLD_utf8_safe(p,e,s,l) toFOLD_utf8_flags_(p,e,s,l, FOLD_FLAGS_FULL) #define toLOWER_utf8_safe(p,e,s,l) _toLOWER_utf8_flags(p,e,s,l, 0) diff --git a/proto.h b/proto.h index 0359a4d6a9e7..883ecdbb13cb 100644 --- a/proto.h +++ b/proto.h @@ -121,11 +121,6 @@ Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ assert(p); assert(e) -PERL_CALLCONV UV -Perl__to_utf8_upper_flags(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); -#define PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS \ - assert(p); assert(ustrp) - PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) __attribute__noreturn__ @@ -5297,6 +5292,11 @@ Perl_to_utf8_title_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *len #define PERL_ARGS_ASSERT_TO_UTF8_TITLE_FLAGS_ \ assert(p); assert(ustrp) +PERL_CALLCONV UV +Perl_to_utf8_upper_flags_(pTHX_ const U8 *p, const U8 *e, U8 *ustrp, STRLEN *lenp, bool flags); +#define PERL_ARGS_ASSERT_TO_UTF8_UPPER_FLAGS_ \ + assert(p); assert(ustrp) + PERL_CALLCONV bool Perl_try_amagic_bin(pTHX_ int method, int flags); #define PERL_ARGS_ASSERT_TRY_AMAGIC_BIN diff --git a/utf8.c b/utf8.c index 9ac9fb8929ee..ba8469aabecf 100644 --- a/utf8.c +++ b/utf8.c @@ -4417,15 +4417,15 @@ S_turkic_uc(pTHX_ const U8 * const p, const U8 * const e, * be used. */ UV -Perl__to_utf8_upper_flags(pTHX_ const U8 *p, +Perl_to_utf8_upper_flags_(pTHX_ const U8 *p, const U8 *e, U8* ustrp, STRLEN *lenp, bool flags) { - UV result; + PERL_ARGS_ASSERT_TO_UTF8_UPPER_FLAGS_; - PERL_ARGS_ASSERT__TO_UTF8_UPPER_FLAGS; + UV result; /* ~0 makes anything non-zero in 'flags' mean we are using locale rules */ /* 2nd char of uc(U+DF) is 'S' */ From d5a3c8704c0c9d95cb78f4297680b3fe2d36158a Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:10:14 -0600 Subject: [PATCH 47/87] Convert _to_utf8_case to legal name --- embed.fnc | 2 +- embed.h | 2 +- proto.h | 12 ++++++------ utf8.c | 14 +++++++------- 4 files changed, 15 insertions(+), 15 deletions(-) diff --git a/embed.fnc b/embed.fnc index ef1099b1e940..f8bde0a445c5 100644 --- a/embed.fnc +++ b/embed.fnc @@ -6183,7 +6183,7 @@ RST |U8 |to_lower_latin1|const U8 c \ |NULLOK U8 *p \ |NULLOK STRLEN *lenp \ |const char dummy -S |UV |_to_utf8_case |const UV original \ +S |UV |to_utf8_case_ |const UV original \ |NULLOK const U8 *p \ |NN U8 *ustrp \ |NN STRLEN *lenp \ diff --git a/embed.h b/embed.h index 2ae958818ea9..f4d289db9297 100644 --- a/embed.h +++ b/embed.h @@ -1722,7 +1722,6 @@ # define sv_derived_from_svpvn(a,b,c,d,e) S_sv_derived_from_svpvn(aTHX_ a,b,c,d,e) # endif # if defined(PERL_IN_UTF8_C) -# define _to_utf8_case(a,b,c,d,e,f,g,h,i) S__to_utf8_case(aTHX_ a,b,c,d,e,f,g,h,i) # define check_locale_boundary_crossing(a,b,c,d) S_check_locale_boundary_crossing(aTHX_ a,b,c,d) # define does_utf8_overflow S_does_utf8_overflow # define isFF_overlong S_isFF_overlong @@ -1730,6 +1729,7 @@ # define new_msg_hv(a,b,c) S_new_msg_hv(aTHX_ a,b,c) # define to_case_cp_list(a,b,c,d,e,f,g,h) S_to_case_cp_list(aTHX_ a,b,c,d,e,f,g,h) # define to_lower_latin1 S_to_lower_latin1 +# define to_utf8_case_(a,b,c,d,e,f,g,h,i) S_to_utf8_case_(aTHX_ a,b,c,d,e,f,g,h,i) # define turkic_fc(a,b,c,d) S_turkic_fc(aTHX_ a,b,c,d) # define turkic_lc(a,b,c,d) S_turkic_lc(aTHX_ a,b,c,d) # define turkic_uc(a,b,c,d) S_turkic_uc(aTHX_ a,b,c,d) diff --git a/proto.h b/proto.h index 883ecdbb13cb..507ed8d92d57 100644 --- a/proto.h +++ b/proto.h @@ -9571,12 +9571,6 @@ S_sv_derived_from_svpvn(pTHX_ SV *sv, SV *namesv, const char *name, const STRLEN #endif /* defined(PERL_IN_UNIVERSAL_C) */ #if defined(PERL_IN_UTF8_C) -STATIC UV -S__to_utf8_case(pTHX_ const UV original, const U8 *p, U8 *ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); -# define PERL_ARGS_ASSERT__TO_UTF8_CASE \ - assert(ustrp); assert(lenp); assert(invlist); assert(invmap); \ - assert(normal) - STATIC UV S_check_locale_boundary_crossing(pTHX_ const U8 * const p, const UV result, U8 * const ustrp, STRLEN *lenp) __attribute__warn_unused_result__; @@ -9599,6 +9593,12 @@ S_to_lower_latin1(const U8 c, U8 *p, STRLEN *lenp, const char dummy) __attribute__warn_unused_result__; # define PERL_ARGS_ASSERT_TO_LOWER_LATIN1 +STATIC UV +S_to_utf8_case_(pTHX_ const UV original, const U8 *p, U8 *ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, const U8 * const aux_table_lengths, const char * const normal); +# define PERL_ARGS_ASSERT_TO_UTF8_CASE_ \ + assert(ustrp); assert(lenp); assert(invlist); assert(invmap); \ + assert(normal) + STATIC UV S_turkic_fc(pTHX_ const U8 * const p, const U8 * const e, U8 *ustrp, STRLEN *lenp); # define PERL_ARGS_ASSERT_TURKIC_FC \ diff --git a/utf8.c b/utf8.c index ba8469aabecf..3a35cea80c26 100644 --- a/utf8.c +++ b/utf8.c @@ -3641,19 +3641,19 @@ Perl_to_upper_title_latin1_(pTHX_ const U8 c, U8* p, STRLEN *lenp, * The functions return the ordinal of the first character in the string of * 'd' */ #define CALL_UPPER_CASE(uv, s, d, lenp) \ - _to_utf8_case(uv, s, d, lenp, PL_utf8_toupper, \ + to_utf8_case_(uv, s, d, lenp, PL_utf8_toupper, \ Uppercase_Mapping_invmap, \ UC_AUX_TABLE_ptrs, \ UC_AUX_TABLE_lengths, \ "uppercase") #define CALL_TITLE_CASE(uv, s, d, lenp) \ - _to_utf8_case(uv, s, d, lenp, PL_utf8_totitle, \ + to_utf8_case_(uv, s, d, lenp, PL_utf8_totitle, \ Titlecase_Mapping_invmap, \ TC_AUX_TABLE_ptrs, \ TC_AUX_TABLE_lengths, \ "titlecase") #define CALL_LOWER_CASE(uv, s, d, lenp) \ - _to_utf8_case(uv, s, d, lenp, PL_utf8_tolower, \ + to_utf8_case_(uv, s, d, lenp, PL_utf8_tolower, \ Lowercase_Mapping_invmap, \ LC_AUX_TABLE_ptrs, \ LC_AUX_TABLE_lengths, \ @@ -3665,12 +3665,12 @@ Perl_to_upper_title_latin1_(pTHX_ const U8 c, U8* p, STRLEN *lenp, * folding); otherwise, when zero, this implies a simple case fold */ #define CALL_FOLD_CASE(uv, s, d, lenp, specials) \ (specials) \ - ? _to_utf8_case(uv, s, d, lenp, PL_utf8_tofold, \ + ? to_utf8_case_(uv, s, d, lenp, PL_utf8_tofold, \ Case_Folding_invmap, \ CF_AUX_TABLE_ptrs, \ CF_AUX_TABLE_lengths, \ "foldcase") \ - : _to_utf8_case(uv, s, d, lenp, PL_utf8_tosimplefold, \ + : to_utf8_case_(uv, s, d, lenp, PL_utf8_tosimplefold, \ Simple_Case_Folding_invmap, \ NULL, NULL, \ "foldcase") @@ -4027,7 +4027,7 @@ S_to_case_cp_list(pTHX_ } STATIC UV -S__to_utf8_case(pTHX_ const UV original, const U8 *p, +S_to_utf8_case_(pTHX_ const UV original, const U8 *p, U8* ustrp, STRLEN *lenp, SV *invlist, const I32 * const invmap, const U32 * const * const aux_tables, @@ -4056,7 +4056,7 @@ S__to_utf8_case(pTHX_ const UV original, const U8 *p, aux_tables, aux_table_lengths, normal); - PERL_ARGS_ASSERT__TO_UTF8_CASE; + PERL_ARGS_ASSERT_TO_UTF8_CASE_; /* If the code point maps to itself and we already have its representation, * copy it instead of recalculating */ From 00f41c41cd411024f4b2a152acc68ef01f490758 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Fri, 15 Aug 2025 10:23:32 -0600 Subject: [PATCH 48/87] Convert _is_uni_perl_idstart to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 4 ++-- proto.h | 10 +++++----- utf8.c | 2 +- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/embed.fnc b/embed.fnc index f8bde0a445c5..67691e67b497 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1723,7 +1723,7 @@ CRp |bool |_is_uni_FOO |const U8 classnum \ |const UV c CRp |bool |_is_uni_perl_idcont \ |UV c -CRp |bool |_is_uni_perl_idstart \ +CRp |bool |is_uni_perl_idstart_ \ |UV c ARTdip |Size_t |isUTF8_CHAR |NN const U8 * const s0 \ |NN const U8 * const e diff --git a/embed.h b/embed.h index f4d289db9297..56464f186bc1 100644 --- a/embed.h +++ b/embed.h @@ -118,7 +118,6 @@ # define SvUV_nomg(a) Perl_SvUV_nomg(aTHX_ a) # define _is_uni_FOO(a,b) Perl__is_uni_FOO(aTHX_ a,b) # define _is_uni_perl_idcont(a) Perl__is_uni_perl_idcont(aTHX_ a) -# define _is_uni_perl_idstart(a) Perl__is_uni_perl_idstart(aTHX_ a) # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) # define _is_utf8_perl_idstart(a,b) Perl__is_utf8_perl_idstart(aTHX_ a,b) @@ -328,6 +327,7 @@ # define Perl_is_strict_utf8_string is_strict_utf8_string # define Perl_is_strict_utf8_string_loc is_strict_utf8_string_loc # define is_strict_utf8_string_loclen Perl_is_strict_utf8_string_loclen +# define is_uni_perl_idstart_(a) Perl_is_uni_perl_idstart_(aTHX_ a) # define is_utf8_FF_helper_ Perl_is_utf8_FF_helper_ # define Perl_is_utf8_char_buf is_utf8_char_buf # define is_utf8_char_helper_ Perl_is_utf8_char_helper_ diff --git a/handy.h b/handy.h index 128eebc7e9db..5dfcf73a4e1c 100644 --- a/handy.h +++ b/handy.h @@ -2151,7 +2151,7 @@ END_EXTERN_C #define isIDCONT_uvchr(c) \ generic_uvchr_(CC_WORDCHAR_, _is_uni_perl_idcont, c) #define isIDFIRST_uvchr(c) \ - generic_uvchr_(CC_IDFIRST_, _is_uni_perl_idstart, c) + generic_uvchr_(CC_IDFIRST_, is_uni_perl_idstart_, c) #define isLOWER_uvchr(c) generic_invlist_uvchr_(CC_LOWER_, c) #define isPRINT_uvchr(c) generic_invlist_uvchr_(CC_PRINT_, c) @@ -2216,7 +2216,7 @@ END_EXTERN_C #define isIDCONT_LC_uvchr(c) generic_LC_uvchr_(isIDCONT_LC, \ _is_uni_perl_idcont, c) #define isIDFIRST_LC_uvchr(c) generic_LC_uvchr_(isIDFIRST_LC, \ - _is_uni_perl_idstart, c) + is_uni_perl_idstart_, c) #define isLOWER_LC_uvchr(c) generic_LC_invlist_uvchr_(isLOWER_LC, CC_LOWER_, c) #define isPRINT_LC_uvchr(c) generic_LC_invlist_uvchr_(isPRINT_LC, CC_PRINT_, c) #define isPSXSPC_LC_uvchr(c) isSPACE_LC_uvchr(c) diff --git a/proto.h b/proto.h index 507ed8d92d57..2c9816839c40 100644 --- a/proto.h +++ b/proto.h @@ -98,11 +98,6 @@ Perl__is_uni_perl_idcont(pTHX_ UV c) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UNI_PERL_IDCONT -PERL_CALLCONV bool -Perl__is_uni_perl_idstart(pTHX_ UV c) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__IS_UNI_PERL_IDSTART - PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) __attribute__warn_unused_result__; @@ -1861,6 +1856,11 @@ Perl_is_strict_utf8_string(const U8 *s, STRLEN len) /* PERL_CALLCONV bool Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ +PERL_CALLCONV bool +Perl_is_uni_perl_idstart_(pTHX_ UV c) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_PERL_IDSTART_ + PERL_CALLCONV Size_t Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool require_partial) __attribute__warn_unused_result__ diff --git a/utf8.c b/utf8.c index 3a35cea80c26..86e9821573f8 100644 --- a/utf8.c +++ b/utf8.c @@ -3549,7 +3549,7 @@ Perl__is_uni_perl_idcont(pTHX_ UV c) } bool -Perl__is_uni_perl_idstart(pTHX_ UV c) +Perl_is_uni_perl_idstart_(pTHX_ UV c) { return _invlist_contains_cp(PL_utf8_perl_idstart, c); } From bb70bee48fa0d2e723beb58c066780caf74c54a4 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Fri, 15 Aug 2025 10:24:35 -0600 Subject: [PATCH 49/87] Convert _is_utf8_perl_idstart to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 4 ++-- proto.h | 12 ++++++------ utf8.c | 4 ++-- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/embed.fnc b/embed.fnc index 67691e67b497..ae8be65983cf 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1767,7 +1767,7 @@ ARTdip |bool |is_utf8_invariant_string_loc \ CRp |bool |_is_utf8_perl_idcont \ |NN const U8 *p \ |NN const U8 * const e -CRp |bool |_is_utf8_perl_idstart \ +CRp |bool |is_utf8_perl_idstart_ \ |NN const U8 *p \ |NN const U8 * const e ARTdmp |bool |is_utf8_string |NN const U8 *s \ diff --git a/embed.h b/embed.h index 56464f186bc1..517f97f153c0 100644 --- a/embed.h +++ b/embed.h @@ -120,7 +120,6 @@ # define _is_uni_perl_idcont(a) Perl__is_uni_perl_idcont(aTHX_ a) # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) -# define _is_utf8_perl_idstart(a,b) Perl__is_utf8_perl_idstart(aTHX_ a,b) # define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) # define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b) # define apply_attrs_string(a,b,c,d) Perl_apply_attrs_string(aTHX_ a,b,c,d) @@ -335,6 +334,7 @@ # define Perl_is_utf8_fixed_width_buf_loc_flags is_utf8_fixed_width_buf_loc_flags # define is_utf8_fixed_width_buf_loclen_flags Perl_is_utf8_fixed_width_buf_loclen_flags # define is_utf8_invariant_string_loc Perl_is_utf8_invariant_string_loc +# define is_utf8_perl_idstart_(a,b) Perl_is_utf8_perl_idstart_(aTHX_ a,b) # define Perl_is_utf8_string is_utf8_string # define is_utf8_string_flags Perl_is_utf8_string_flags # define Perl_is_utf8_string_loc is_utf8_string_loc diff --git a/handy.h b/handy.h index 5dfcf73a4e1c..4ec1ff743093 100644 --- a/handy.h +++ b/handy.h @@ -2347,7 +2347,7 @@ END_EXTERN_C * modern Unicode definition */ #define isIDFIRST_utf8_safe(p, e) \ generic_func_utf8_safe_(CC_IDFIRST_, \ - _is_utf8_perl_idstart, (U8 *) (p), (U8 *) (e)) + is_utf8_perl_idstart_, (U8 *) (p), (U8 *) (e)) #define isLOWER_utf8_safe(p, e) generic_invlist_utf8_safe_(CC_LOWER_, p, e) #define isPRINT_utf8_safe(p, e) generic_invlist_utf8_safe_(CC_PRINT_, p, e) @@ -2450,7 +2450,7 @@ END_EXTERN_C _is_utf8_perl_idcont, p, e) #define isIDFIRST_LC_utf8_safe(p, e) \ generic_LC_func_utf8_safe_(isIDFIRST_LC, \ - _is_utf8_perl_idstart, p, e) + is_utf8_perl_idstart_, p, e) #define isLOWER_LC_utf8_safe(p, e) \ generic_LC_invlist_utf8_safe_(isLOWER_LC, CC_LOWER_, p, e) #define isPRINT_LC_utf8_safe(p, e) \ diff --git a/proto.h b/proto.h index 2c9816839c40..44994c5ed2c3 100644 --- a/proto.h +++ b/proto.h @@ -110,12 +110,6 @@ Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ assert(p); assert(e) -PERL_CALLCONV bool -Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART \ - assert(p); assert(e) - PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) __attribute__noreturn__ @@ -1884,6 +1878,12 @@ Perl_is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 fla /* PERL_CALLCONV bool Perl_is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */ +PERL_CALLCONV bool +Perl_is_utf8_perl_idstart_(pTHX_ const U8 *p, const U8 * const e) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UTF8_PERL_IDSTART_ \ + assert(p); assert(e) + /* PERL_CALLCONV bool Perl_is_utf8_string(const U8 *s, STRLEN len) __attribute__warn_unused_result__; */ diff --git a/utf8.c b/utf8.c index 86e9821573f8..daae3a6de2d6 100644 --- a/utf8.c +++ b/utf8.c @@ -3914,9 +3914,9 @@ Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) } bool -Perl__is_utf8_perl_idstart(pTHX_ const U8 *p, const U8 * const e) +Perl_is_utf8_perl_idstart_(pTHX_ const U8 *p, const U8 * const e) { - PERL_ARGS_ASSERT__IS_UTF8_PERL_IDSTART; + PERL_ARGS_ASSERT_IS_UTF8_PERL_IDSTART_; return IS_UTF8_IN_INVLIST(p, e, PL_utf8_perl_idstart); } From 71dac19ce3ad396eb6d6e8499f5690745d638b8e Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Fri, 15 Aug 2025 10:25:56 -0600 Subject: [PATCH 50/87] Convert _is_uni_perl_idcont to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 4 ++-- proto.h | 10 +++++----- utf8.c | 2 +- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/embed.fnc b/embed.fnc index ae8be65983cf..bf1596416a7c 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1721,7 +1721,7 @@ ATdip |bool |is_strict_utf8_string_loclen \ |NULLOK STRLEN *el CRp |bool |_is_uni_FOO |const U8 classnum \ |const UV c -CRp |bool |_is_uni_perl_idcont \ +CRp |bool |is_uni_perl_idcont_ \ |UV c CRp |bool |is_uni_perl_idstart_ \ |UV c diff --git a/embed.h b/embed.h index 517f97f153c0..fae12d368586 100644 --- a/embed.h +++ b/embed.h @@ -117,7 +117,6 @@ # define SvUV(a) Perl_SvUV(aTHX_ a) # define SvUV_nomg(a) Perl_SvUV_nomg(aTHX_ a) # define _is_uni_FOO(a,b) Perl__is_uni_FOO(aTHX_ a,b) -# define _is_uni_perl_idcont(a) Perl__is_uni_perl_idcont(aTHX_ a) # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) # define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) @@ -326,6 +325,7 @@ # define Perl_is_strict_utf8_string is_strict_utf8_string # define Perl_is_strict_utf8_string_loc is_strict_utf8_string_loc # define is_strict_utf8_string_loclen Perl_is_strict_utf8_string_loclen +# define is_uni_perl_idcont_(a) Perl_is_uni_perl_idcont_(aTHX_ a) # define is_uni_perl_idstart_(a) Perl_is_uni_perl_idstart_(aTHX_ a) # define is_utf8_FF_helper_ Perl_is_utf8_FF_helper_ # define Perl_is_utf8_char_buf is_utf8_char_buf diff --git a/handy.h b/handy.h index 4ec1ff743093..d96640989f32 100644 --- a/handy.h +++ b/handy.h @@ -2149,7 +2149,7 @@ END_EXTERN_C #define isDIGIT_uvchr(c) generic_invlist_uvchr_(CC_DIGIT_, c) #define isGRAPH_uvchr(c) generic_invlist_uvchr_(CC_GRAPH_, c) #define isIDCONT_uvchr(c) \ - generic_uvchr_(CC_WORDCHAR_, _is_uni_perl_idcont, c) + generic_uvchr_(CC_WORDCHAR_, is_uni_perl_idcont_, c) #define isIDFIRST_uvchr(c) \ generic_uvchr_(CC_IDFIRST_, is_uni_perl_idstart_, c) #define isLOWER_uvchr(c) generic_invlist_uvchr_(CC_LOWER_, c) @@ -2214,7 +2214,7 @@ END_EXTERN_C #define isDIGIT_LC_uvchr(c) generic_LC_invlist_uvchr_(isDIGIT_LC, CC_DIGIT_, c) #define isGRAPH_LC_uvchr(c) generic_LC_invlist_uvchr_(isGRAPH_LC, CC_GRAPH_, c) #define isIDCONT_LC_uvchr(c) generic_LC_uvchr_(isIDCONT_LC, \ - _is_uni_perl_idcont, c) + is_uni_perl_idcont_, c) #define isIDFIRST_LC_uvchr(c) generic_LC_uvchr_(isIDFIRST_LC, \ is_uni_perl_idstart_, c) #define isLOWER_LC_uvchr(c) generic_LC_invlist_uvchr_(isLOWER_LC, CC_LOWER_, c) diff --git a/proto.h b/proto.h index 44994c5ed2c3..0a3a67c75271 100644 --- a/proto.h +++ b/proto.h @@ -93,11 +93,6 @@ Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) __attribute__warn_unused_result__; #define PERL_ARGS_ASSERT__IS_UNI_FOO -PERL_CALLCONV bool -Perl__is_uni_perl_idcont(pTHX_ UV c) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__IS_UNI_PERL_IDCONT - PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) __attribute__warn_unused_result__; @@ -1850,6 +1845,11 @@ Perl_is_strict_utf8_string(const U8 *s, STRLEN len) /* PERL_CALLCONV bool Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ +PERL_CALLCONV bool +Perl_is_uni_perl_idcont_(pTHX_ UV c) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_PERL_IDCONT_ + PERL_CALLCONV bool Perl_is_uni_perl_idstart_(pTHX_ UV c) __attribute__warn_unused_result__; diff --git a/utf8.c b/utf8.c index daae3a6de2d6..e58bcd54ba7b 100644 --- a/utf8.c +++ b/utf8.c @@ -3543,7 +3543,7 @@ Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) } bool -Perl__is_uni_perl_idcont(pTHX_ UV c) +Perl_is_uni_perl_idcont_(pTHX_ UV c) { return _invlist_contains_cp(PL_utf8_perl_idcont, c); } From 1b402a6f4bf1429e2c68e3fe1fb3195affa1adda Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Fri, 15 Aug 2025 10:28:06 -0600 Subject: [PATCH 51/87] Convert _is_utf8_perl_idcont to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 4 ++-- proto.h | 12 ++++++------ utf8.c | 4 ++-- 5 files changed, 12 insertions(+), 12 deletions(-) diff --git a/embed.fnc b/embed.fnc index bf1596416a7c..a463e6e7881d 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1764,7 +1764,7 @@ ARTdip |bool |is_utf8_invariant_string_loc \ |NN const U8 * const s \ |STRLEN len \ |NULLOK const U8 **ep -CRp |bool |_is_utf8_perl_idcont \ +CRp |bool |is_utf8_perl_idcont_ \ |NN const U8 *p \ |NN const U8 * const e CRp |bool |is_utf8_perl_idstart_ \ diff --git a/embed.h b/embed.h index fae12d368586..ab96b56969f7 100644 --- a/embed.h +++ b/embed.h @@ -118,7 +118,6 @@ # define SvUV_nomg(a) Perl_SvUV_nomg(aTHX_ a) # define _is_uni_FOO(a,b) Perl__is_uni_FOO(aTHX_ a,b) # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) -# define _is_utf8_perl_idcont(a,b) Perl__is_utf8_perl_idcont(aTHX_ a,b) # define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) # define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b) # define apply_attrs_string(a,b,c,d) Perl_apply_attrs_string(aTHX_ a,b,c,d) @@ -334,6 +333,7 @@ # define Perl_is_utf8_fixed_width_buf_loc_flags is_utf8_fixed_width_buf_loc_flags # define is_utf8_fixed_width_buf_loclen_flags Perl_is_utf8_fixed_width_buf_loclen_flags # define is_utf8_invariant_string_loc Perl_is_utf8_invariant_string_loc +# define is_utf8_perl_idcont_(a,b) Perl_is_utf8_perl_idcont_(aTHX_ a,b) # define is_utf8_perl_idstart_(a,b) Perl_is_utf8_perl_idstart_(aTHX_ a,b) # define Perl_is_utf8_string is_utf8_string # define is_utf8_string_flags Perl_is_utf8_string_flags diff --git a/handy.h b/handy.h index d96640989f32..2e8c51067014 100644 --- a/handy.h +++ b/handy.h @@ -2337,7 +2337,7 @@ END_EXTERN_C _is_utf8_FOO(CC_DIGIT_, p, e)) #define isGRAPH_utf8_safe(p, e) generic_invlist_utf8_safe_(CC_GRAPH_, p, e) #define isIDCONT_utf8_safe(p, e) generic_func_utf8_safe_(CC_WORDCHAR_, \ - _is_utf8_perl_idcont, p, e) + is_utf8_perl_idcont_, p, e) /* To prevent S_scan_word in toke.c from hanging, we have to make sure that * IDFIRST is an alnum. See @@ -2447,7 +2447,7 @@ END_EXTERN_C generic_LC_invlist_utf8_safe_(isGRAPH_LC, CC_GRAPH_, p, e) #define isIDCONT_LC_utf8_safe(p, e) \ generic_LC_func_utf8_safe_(isIDCONT_LC, \ - _is_utf8_perl_idcont, p, e) + is_utf8_perl_idcont_, p, e) #define isIDFIRST_LC_utf8_safe(p, e) \ generic_LC_func_utf8_safe_(isIDFIRST_LC, \ is_utf8_perl_idstart_, p, e) diff --git a/proto.h b/proto.h index 0a3a67c75271..e72ed1dc987f 100644 --- a/proto.h +++ b/proto.h @@ -99,12 +99,6 @@ Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) #define PERL_ARGS_ASSERT__IS_UTF8_FOO \ assert(p); assert(e) -PERL_CALLCONV bool -Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT \ - assert(p); assert(e) - PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) __attribute__noreturn__ @@ -1878,6 +1872,12 @@ Perl_is_utf8_fixed_width_buf_flags(const U8 * const s, STRLEN len, const U32 fla /* PERL_CALLCONV bool Perl_is_utf8_fixed_width_buf_loc_flags(const U8 * const s, STRLEN len, const U8 **ep, const U32 flags); */ +PERL_CALLCONV bool +Perl_is_utf8_perl_idcont_(pTHX_ const U8 *p, const U8 * const e) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UTF8_PERL_IDCONT_ \ + assert(p); assert(e) + PERL_CALLCONV bool Perl_is_utf8_perl_idstart_(pTHX_ const U8 *p, const U8 * const e) __attribute__warn_unused_result__; diff --git a/utf8.c b/utf8.c index e58bcd54ba7b..f2b455000e42 100644 --- a/utf8.c +++ b/utf8.c @@ -3922,9 +3922,9 @@ Perl_is_utf8_perl_idstart_(pTHX_ const U8 *p, const U8 * const e) } bool -Perl__is_utf8_perl_idcont(pTHX_ const U8 *p, const U8 * const e) +Perl_is_utf8_perl_idcont_(pTHX_ const U8 *p, const U8 * const e) { - PERL_ARGS_ASSERT__IS_UTF8_PERL_IDCONT; + PERL_ARGS_ASSERT_IS_UTF8_PERL_IDCONT_; return IS_UTF8_IN_INVLIST(p, e, PL_utf8_perl_idcont); } From 1161aa16655db18c0c623b270a6957d05083fc52 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:18:10 -0600 Subject: [PATCH 52/87] Convert _is_uni_FOO to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 4 ++-- proto.h | 10 +++++----- utf8.c | 2 +- 5 files changed, 10 insertions(+), 10 deletions(-) diff --git a/embed.fnc b/embed.fnc index a463e6e7881d..0db1f480f893 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1719,7 +1719,7 @@ ATdip |bool |is_strict_utf8_string_loclen \ |STRLEN len \ |NULLOK const U8 **ep \ |NULLOK STRLEN *el -CRp |bool |_is_uni_FOO |const U8 classnum \ +CRp |bool |is_uni_FOO_ |const U8 classnum \ |const UV c CRp |bool |is_uni_perl_idcont_ \ |UV c diff --git a/embed.h b/embed.h index ab96b56969f7..1cd981d2af9b 100644 --- a/embed.h +++ b/embed.h @@ -116,7 +116,6 @@ # define SvTRUE_nomg(a) Perl_SvTRUE_nomg(aTHX_ a) # define SvUV(a) Perl_SvUV(aTHX_ a) # define SvUV_nomg(a) Perl_SvUV_nomg(aTHX_ a) -# define _is_uni_FOO(a,b) Perl__is_uni_FOO(aTHX_ a,b) # define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) # define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b) @@ -324,6 +323,7 @@ # define Perl_is_strict_utf8_string is_strict_utf8_string # define Perl_is_strict_utf8_string_loc is_strict_utf8_string_loc # define is_strict_utf8_string_loclen Perl_is_strict_utf8_string_loclen +# define is_uni_FOO_(a,b) Perl_is_uni_FOO_(aTHX_ a,b) # define is_uni_perl_idcont_(a) Perl_is_uni_perl_idcont_(aTHX_ a) # define is_uni_perl_idstart_(a) Perl_is_uni_perl_idstart_(aTHX_ a) # define is_utf8_FF_helper_ Perl_is_utf8_FF_helper_ diff --git a/handy.h b/handy.h index 2e8c51067014..b45154b1df5e 100644 --- a/handy.h +++ b/handy.h @@ -2140,7 +2140,7 @@ END_EXTERN_C : above_latin1(c)) #define generic_invlist_uvchr_(classnum, c) ((c) < 256 \ ? generic_isCC_(c, classnum) \ - : _is_uni_FOO(classnum, c)) + : is_uni_FOO_(classnum, c)) #define isALPHA_uvchr(c) generic_invlist_uvchr_(CC_ALPHA_, c) #define isALPHANUMERIC_uvchr(c) generic_invlist_uvchr_(CC_ALPHANUMERIC_, c) #define isASCII_uvchr(c) isASCII(c) @@ -2202,7 +2202,7 @@ END_EXTERN_C #define generic_LC_uvchr_(latin1, above_latin1, c) \ (c < 256 ? latin1(c) : above_latin1(c)) #define generic_LC_invlist_uvchr_(latin1, classnum, c) \ - (c < 256 ? latin1(c) : _is_uni_FOO(classnum, c)) + (c < 256 ? latin1(c) : is_uni_FOO_(classnum, c)) #define isALPHA_LC_uvchr(c) generic_LC_invlist_uvchr_(isALPHA_LC, CC_ALPHA_, c) #define isALPHANUMERIC_LC_uvchr(c) generic_LC_invlist_uvchr_(isALPHANUMERIC_LC, \ diff --git a/proto.h b/proto.h index e72ed1dc987f..c6065e711fa6 100644 --- a/proto.h +++ b/proto.h @@ -88,11 +88,6 @@ Perl_Slab_Free(pTHX_ void *op); /* PERL_CALLCONV void Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ -PERL_CALLCONV bool -Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__IS_UNI_FOO - PERL_CALLCONV bool Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) __attribute__warn_unused_result__; @@ -1839,6 +1834,11 @@ Perl_is_strict_utf8_string(const U8 *s, STRLEN len) /* PERL_CALLCONV bool Perl_is_strict_utf8_string_loc(const U8 *s, STRLEN len, const U8 **ep); */ +PERL_CALLCONV bool +Perl_is_uni_FOO_(pTHX_ const U8 classnum, const UV c) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UNI_FOO_ + PERL_CALLCONV bool Perl_is_uni_perl_idcont_(pTHX_ UV c) __attribute__warn_unused_result__; diff --git a/utf8.c b/utf8.c index f2b455000e42..2f76f527ccb5 100644 --- a/utf8.c +++ b/utf8.c @@ -3537,7 +3537,7 @@ Perl_utf8_to_utf16_base(pTHX_ U8* s, U8* d, Size_t bytelen, Size_t *newlen, } bool -Perl__is_uni_FOO(pTHX_ const U8 classnum, const UV c) +Perl_is_uni_FOO_(pTHX_ const U8 classnum, const UV c) { return _invlist_contains_cp(PL_XPosix_ptrs[classnum], c); } From e81a0a9ce86ccfb35269fa82628bd61353a16829 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:20:14 -0600 Subject: [PATCH 53/87] Convert _is_utf8_FOO to legal name --- embed.fnc | 2 +- embed.h | 2 +- handy.h | 6 +++--- proto.h | 12 ++++++------ utf8.c | 4 ++-- 5 files changed, 13 insertions(+), 13 deletions(-) diff --git a/embed.fnc b/embed.fnc index 0db1f480f893..164af7d25d11 100644 --- a/embed.fnc +++ b/embed.fnc @@ -1757,7 +1757,7 @@ ATdip |bool |is_utf8_fixed_width_buf_loclen_flags \ |NULLOK const U8 **ep \ |NULLOK STRLEN *el \ |const U32 flags -CRp |bool |_is_utf8_FOO |const U8 classnum \ +CRp |bool |is_utf8_FOO_ |const U8 classnum \ |NN const U8 *p \ |NN const U8 * const e ARTdip |bool |is_utf8_invariant_string_loc \ diff --git a/embed.h b/embed.h index 1cd981d2af9b..2035b301b28c 100644 --- a/embed.h +++ b/embed.h @@ -116,7 +116,6 @@ # define SvTRUE_nomg(a) Perl_SvTRUE_nomg(aTHX_ a) # define SvUV(a) Perl_SvUV(aTHX_ a) # define SvUV_nomg(a) Perl_SvUV_nomg(aTHX_ a) -# define _is_utf8_FOO(a,b,c) Perl__is_utf8_FOO(aTHX_ a,b,c) # define amagic_call(a,b,c,d) Perl_amagic_call(aTHX_ a,b,c,d) # define amagic_deref_call(a,b) Perl_amagic_deref_call(aTHX_ a,b) # define apply_attrs_string(a,b,c,d) Perl_apply_attrs_string(aTHX_ a,b,c,d) @@ -327,6 +326,7 @@ # define is_uni_perl_idcont_(a) Perl_is_uni_perl_idcont_(aTHX_ a) # define is_uni_perl_idstart_(a) Perl_is_uni_perl_idstart_(aTHX_ a) # define is_utf8_FF_helper_ Perl_is_utf8_FF_helper_ +# define is_utf8_FOO_(a,b,c) Perl_is_utf8_FOO_(aTHX_ a,b,c) # define Perl_is_utf8_char_buf is_utf8_char_buf # define is_utf8_char_helper_ Perl_is_utf8_char_helper_ # define Perl_is_utf8_fixed_width_buf_flags is_utf8_fixed_width_buf_flags diff --git a/handy.h b/handy.h index b45154b1df5e..df33bb9f1ca0 100644 --- a/handy.h +++ b/handy.h @@ -2279,7 +2279,7 @@ END_EXTERN_C /* Like the above, but passes classnum to _isFOO_utf8(), instead of having an * 'above_latin1' parameter */ #define generic_invlist_utf8_safe_(classnum, p, e) \ - generic_utf8_safe_(classnum, p, e, _is_utf8_FOO(classnum, p, e)) + generic_utf8_safe_(classnum, p, e, is_utf8_FOO_(classnum, p, e)) /* Like the above, but should be used only when it is known that there are no * characters in the upper-Latin1 range (128-255 on ASCII platforms) which the @@ -2334,7 +2334,7 @@ END_EXTERN_C #define isDIGIT_utf8_safe(p, e) \ generic_utf8_safe_no_upper_latin1_(CC_DIGIT_, p, e, \ - _is_utf8_FOO(CC_DIGIT_, p, e)) + is_utf8_FOO_(CC_DIGIT_, p, e)) #define isGRAPH_utf8_safe(p, e) generic_invlist_utf8_safe_(CC_GRAPH_, p, e) #define isIDCONT_utf8_safe(p, e) generic_func_utf8_safe_(CC_WORDCHAR_, \ is_utf8_perl_idcont_, p, e) @@ -2418,7 +2418,7 @@ END_EXTERN_C #define generic_LC_invlist_utf8_safe_(macro, classnum, p, e) \ generic_LC_utf8_safe_(macro, p, e, \ - _is_utf8_FOO(classnum, p, e)) + is_utf8_FOO_(classnum, p, e)) #define generic_LC_func_utf8_safe_(macro, above_latin1, p, e) \ generic_LC_utf8_safe_(macro, p, e, above_latin1(p, e)) diff --git a/proto.h b/proto.h index c6065e711fa6..1e6c97ad909b 100644 --- a/proto.h +++ b/proto.h @@ -88,12 +88,6 @@ Perl_Slab_Free(pTHX_ void *op); /* PERL_CALLCONV void Perl_SvREFCNT_dec_set_NULL(pTHX_ SV *sv); */ -PERL_CALLCONV bool -Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) - __attribute__warn_unused_result__; -#define PERL_ARGS_ASSERT__IS_UTF8_FOO \ - assert(p); assert(e) - PERL_CALLCONV_NO_RET void Perl_abort_execution(pTHX_ SV *msg_sv, const char * const name) __attribute__noreturn__ @@ -1856,6 +1850,12 @@ Perl_is_utf8_FF_helper_(const U8 * const s0, const U8 * const e, const bool requ #define PERL_ARGS_ASSERT_IS_UTF8_FF_HELPER_ \ assert(s0); assert(e) +PERL_CALLCONV bool +Perl_is_utf8_FOO_(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) + __attribute__warn_unused_result__; +#define PERL_ARGS_ASSERT_IS_UTF8_FOO_ \ + assert(p); assert(e) + /* PERL_CALLCONV STRLEN Perl_is_utf8_char_buf(const U8 *buf, const U8 *buf_end); */ diff --git a/utf8.c b/utf8.c index 2f76f527ccb5..d72de4e60c96 100644 --- a/utf8.c +++ b/utf8.c @@ -3906,9 +3906,9 @@ S_warn_on_first_deprecated_use(pTHX_ U32 category, _invlist_contains_cp(invlist, utf8_to_uv_or_die(p, e, NULL)) bool -Perl__is_utf8_FOO(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) +Perl_is_utf8_FOO_(pTHX_ const U8 classnum, const U8 *p, const U8 * const e) { - PERL_ARGS_ASSERT__IS_UTF8_FOO; + PERL_ARGS_ASSERT_IS_UTF8_FOO_; return IS_UTF8_IN_INVLIST(p, e, PL_XPosix_ptrs[classnum]); } From 1668672b84c72b69b5fa94af5016c9324be02472 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:24:06 -0600 Subject: [PATCH 54/87] Convert _utf8_safe_assert to legal name --- handy.h | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/handy.h b/handy.h index df33bb9f1ca0..712f06aa5246 100644 --- a/handy.h +++ b/handy.h @@ -2249,13 +2249,13 @@ END_EXTERN_C * bunch of code in toke.c assumes that this is true, so the assertion allows * for that */ #ifdef PERL_IN_TOKE_C -# define _utf8_safe_assert(p,e) ((e) > (p) || ((e) == (p) && *(p) == '\0')) +# define utf8_safe_assert_(p,e) ((e) > (p) || ((e) == (p) && *(p) == '\0')) #else -# define _utf8_safe_assert(p,e) ((e) > (p)) +# define utf8_safe_assert_(p,e) ((e) > (p)) #endif #define generic_utf8_safe_(classnum, p, e, above_latin1) \ - ((! _utf8_safe_assert(p, e)) \ + ((! utf8_safe_assert_(p, e)) \ ? (force_out_malformed_utf8_message_((U8 *) (p), (U8 *) (e), 0, MALFORMED_UTF8_DIE), 0)\ : (UTF8_IS_INVARIANT(*(p))) \ ? generic_isCC_(*(p), classnum) \ @@ -2286,7 +2286,7 @@ END_EXTERN_C * class is TRUE for. Hence it can skip the tests for this range. * 'above_latin1' should include its arguments */ #define generic_utf8_safe_no_upper_latin1_(classnum, p, e, above_latin1) \ - (__ASSERT_(_utf8_safe_assert(p, e)) \ + (__ASSERT_(utf8_safe_assert_(p, e)) \ (isASCII(*(p))) \ ? generic_isCC_(*(p), classnum) \ : (UTF8_IS_DOWNGRADEABLE_START(*(p))) \ @@ -2319,7 +2319,7 @@ END_EXTERN_C #define isASCII_utf8_safe(p, e) \ /* Because ASCII is invariant under utf8, the non-utf8 macro \ * works */ \ - (__ASSERT_(_utf8_safe_assert(p, e)) isASCII(*(p))) + (assert_(utf8_safe_assert_(p, e)) isASCII(*(p))) #define isBLANK_utf8_safe(p, e) \ generic_non_invlist_utf8_safe_(CC_BLANK_, is_HORIZWS_high, p, e) @@ -2327,7 +2327,7 @@ END_EXTERN_C /* Because all controls are UTF-8 invariants in EBCDIC, we can use this * more efficient macro instead of the more general one */ # define isCNTRL_utf8_safe(p, e) \ - (__ASSERT_(_utf8_safe_assert(p, e)) isCNTRL_L1(*(p))) + (assert_(utf8_safe_assert_(p, e)) isCNTRL_L1(*(p))) #else # define isCNTRL_utf8_safe(p, e) generic_utf8_safe_(CC_CNTRL_, p, e, 0) #endif @@ -2406,7 +2406,7 @@ END_EXTERN_C * point in 'p' is within the 0-255 range, it uses locale rules from the * passed-in 'macro' parameter */ #define generic_LC_utf8_safe_(macro, p, e, above_latin1) \ - (__ASSERT_(_utf8_safe_assert(p, e)) \ + (assert_(utf8_safe_assert_(p, e)) \ (UTF8_IS_INVARIANT(*(p))) \ ? macro(*(p)) \ : (UTF8_IS_DOWNGRADEABLE_START(*(p)) \ @@ -2436,7 +2436,7 @@ END_EXTERN_C #define isALPHA_LC_utf8_safe(p, e) \ generic_LC_invlist_utf8_safe_(isALPHA_LC, CC_ALPHA_, p, e) #define isASCII_LC_utf8_safe(p, e) \ - (__ASSERT_(_utf8_safe_assert(p, e)) isASCII_LC(*(p))) + (assert_(utf8_safe_assert_(p, e)) isASCII_LC(*(p))) #define isBLANK_LC_utf8_safe(p, e) \ generic_LC_non_invlist_utf8_safe_(isBLANK_LC, is_HORIZWS_high, p, e) #define isCNTRL_LC_utf8_safe(p, e) \ From 54f3f4e3b1bff47385173fffaaec55dc18ecba02 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Fri, 15 Aug 2025 10:35:36 -0600 Subject: [PATCH 55/87] Convert _toLOWER_utf8_flags to legal name --- handy.h | 4 ++-- pp.c | 10 +++++----- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/handy.h b/handy.h index 712f06aa5246..43e4568e08c3 100644 --- a/handy.h +++ b/handy.h @@ -2374,12 +2374,12 @@ END_EXTERN_C /* For internal core use only, subject to change */ #define toFOLD_utf8_flags_(p,e,s,l,f) to_utf8_fold_flags_(p,e,s,l,f) -#define _toLOWER_utf8_flags(p,e,s,l,f) to_utf8_lower_flags_(p,e,s,l,f) +#define toLOWER_utf8_flags_(p,e,s,l,f) to_utf8_lower_flags_(p,e,s,l,f) #define _toTITLE_utf8_flags(p,e,s,l,f) to_utf8_title_flags_(p,e,s,l,f) #define _toUPPER_utf8_flags(p,e,s,l,f) to_utf8_upper_flags_(p,e,s,l,f) #define toFOLD_utf8_safe(p,e,s,l) toFOLD_utf8_flags_(p,e,s,l, FOLD_FLAGS_FULL) -#define toLOWER_utf8_safe(p,e,s,l) _toLOWER_utf8_flags(p,e,s,l, 0) +#define toLOWER_utf8_safe(p,e,s,l) toLOWER_utf8_flags_(p,e,s,l, 0) #define toTITLE_utf8_safe(p,e,s,l) _toTITLE_utf8_flags(p,e,s,l, 0) #define toUPPER_utf8_safe(p,e,s,l) _toUPPER_utf8_flags(p,e,s,l, 0) diff --git a/pp.c b/pp.c index 6725f5582984..16bda708e80d 100644 --- a/pp.c +++ b/pp.c @@ -4160,7 +4160,7 @@ PP_wrapped(pp_ucfirst, 1, 0) #ifdef USE_LOCALE_CTYPE - _toLOWER_utf8_flags(s, s + slen, tmpbuf, &tculen, IN_LC_RUNTIME(LC_CTYPE)); + toLOWER_utf8_flags_(s, s + slen, tmpbuf, &tculen, IN_LC_RUNTIME(LC_CTYPE)); /* In turkic locales, lower casing an 'I' normally yields U+0131, * LATIN SMALL LETTER DOTLESS I, but not if the grapheme also @@ -4192,7 +4192,7 @@ PP_wrapped(pp_ucfirst, 1, 0) #else PERL_UNUSED_VAR(remove_dot_above); - _toLOWER_utf8_flags(s, s + slen, tmpbuf, &tculen, 0); + toLOWER_utf8_flags_(s, s + slen, tmpbuf, &tculen, 0); #endif } @@ -4874,7 +4874,7 @@ PP_wrapped(pp_lc, 1, 0) #ifdef USE_LOCALE_CTYPE - _toLOWER_utf8_flags(s, send, tmpbuf, &lower_len, + toLOWER_utf8_flags_(s, send, tmpbuf, &lower_len, IN_LC_RUNTIME(LC_CTYPE)); /* If we are in a Turkic locale, we have to do more work. As noted @@ -4884,7 +4884,7 @@ PP_wrapped(pp_lc, 1, 0) * and set a flag if the DOT is there. Then each time through the * loop, we have to see if we need to remove the next DOT above, * and if so, do it. We know that there is a DOT because - * _toLOWER_utf8_flags() wouldn't have returned 'i' unless there + * toLOWER_utf8_flags_() wouldn't have returned 'i' unless there * was one in a proper position. */ if ( UNLIKELY(IN_UTF8_TURKIC_LOCALE) && IN_LC_RUNTIME(LC_CTYPE)) @@ -4904,7 +4904,7 @@ PP_wrapped(pp_lc, 1, 0) #else PERL_UNUSED_VAR(remove_dot_above); - _toLOWER_utf8_flags(s, send, tmpbuf, &lower_len, 0); + toLOWER_utf8_flags_(s, send, tmpbuf, &lower_len, 0); #endif /* Here is where we would do context-sensitive actions for the From 122894f975466e58c6270ad2508533012b894f5b Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:52:36 -0600 Subject: [PATCH 56/87] Convert _toTITLE_utf8_flags to legal name --- handy.h | 4 ++-- pp.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/handy.h b/handy.h index 43e4568e08c3..7b8b58b6ef5d 100644 --- a/handy.h +++ b/handy.h @@ -2375,12 +2375,12 @@ END_EXTERN_C /* For internal core use only, subject to change */ #define toFOLD_utf8_flags_(p,e,s,l,f) to_utf8_fold_flags_(p,e,s,l,f) #define toLOWER_utf8_flags_(p,e,s,l,f) to_utf8_lower_flags_(p,e,s,l,f) -#define _toTITLE_utf8_flags(p,e,s,l,f) to_utf8_title_flags_(p,e,s,l,f) +#define toTITLE_utf8_flags_(p,e,s,l,f) to_utf8_title_flags_(p,e,s,l,f) #define _toUPPER_utf8_flags(p,e,s,l,f) to_utf8_upper_flags_(p,e,s,l,f) #define toFOLD_utf8_safe(p,e,s,l) toFOLD_utf8_flags_(p,e,s,l, FOLD_FLAGS_FULL) #define toLOWER_utf8_safe(p,e,s,l) toLOWER_utf8_flags_(p,e,s,l, 0) -#define toTITLE_utf8_safe(p,e,s,l) _toTITLE_utf8_flags(p,e,s,l, 0) +#define toTITLE_utf8_safe(p,e,s,l) toTITLE_utf8_flags_(p,e,s,l, 0) #define toUPPER_utf8_safe(p,e,s,l) _toUPPER_utf8_flags(p,e,s,l, 0) #define isALPHA_LC_utf8(p, e) isALPHA_LC_utf8_safe(p, e) diff --git a/pp.c b/pp.c index 16bda708e80d..3ca52395d83f 100644 --- a/pp.c +++ b/pp.c @@ -4151,9 +4151,9 @@ PP_wrapped(pp_ucfirst, 1, 0) if (op_type == OP_UCFIRST) { #ifdef USE_LOCALE_CTYPE - _toTITLE_utf8_flags(s, s +slen, tmpbuf, &tculen, IN_LC_RUNTIME(LC_CTYPE)); + toTITLE_utf8_flags_(s, s +slen, tmpbuf, &tculen, IN_LC_RUNTIME(LC_CTYPE)); #else - _toTITLE_utf8_flags(s, s +slen, tmpbuf, &tculen, 0); + toTITLE_utf8_flags_(s, s +slen, tmpbuf, &tculen, 0); #endif } else { From 5e724d38b35db9de21f7f5dff52a8dd9fe1ae0e3 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:55:31 -0600 Subject: [PATCH 57/87] Convert _toUPPER_utf8_flags to legal name --- handy.h | 4 ++-- pp.c | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/handy.h b/handy.h index 7b8b58b6ef5d..4d705c1a9d5c 100644 --- a/handy.h +++ b/handy.h @@ -2376,12 +2376,12 @@ END_EXTERN_C #define toFOLD_utf8_flags_(p,e,s,l,f) to_utf8_fold_flags_(p,e,s,l,f) #define toLOWER_utf8_flags_(p,e,s,l,f) to_utf8_lower_flags_(p,e,s,l,f) #define toTITLE_utf8_flags_(p,e,s,l,f) to_utf8_title_flags_(p,e,s,l,f) -#define _toUPPER_utf8_flags(p,e,s,l,f) to_utf8_upper_flags_(p,e,s,l,f) +#define toUPPER_utf8_flags_(p,e,s,l,f) to_utf8_upper_flags_(p,e,s,l,f) #define toFOLD_utf8_safe(p,e,s,l) toFOLD_utf8_flags_(p,e,s,l, FOLD_FLAGS_FULL) #define toLOWER_utf8_safe(p,e,s,l) toLOWER_utf8_flags_(p,e,s,l, 0) #define toTITLE_utf8_safe(p,e,s,l) toTITLE_utf8_flags_(p,e,s,l, 0) -#define toUPPER_utf8_safe(p,e,s,l) _toUPPER_utf8_flags(p,e,s,l, 0) +#define toUPPER_utf8_safe(p,e,s,l) toUPPER_utf8_flags_(p,e,s,l, 0) #define isALPHA_LC_utf8(p, e) isALPHA_LC_utf8_safe(p, e) #define isALPHANUMERIC_LC_utf8(p, e) isALPHANUMERIC_LC_utf8_safe(p, e) diff --git a/pp.c b/pp.c index 3ca52395d83f..693f862a6e1a 100644 --- a/pp.c +++ b/pp.c @@ -4546,10 +4546,10 @@ PP_wrapped(pp_uc, 1, 0) * and copy it to the output buffer */ #ifdef USE_LOCALE_CTYPE - uv = _toUPPER_utf8_flags(s, send, tmpbuf, &upper_len, + uv = toUPPER_utf8_flags_(s, send, tmpbuf, &upper_len, IN_LC_RUNTIME(LC_CTYPE)); #else - uv = _toUPPER_utf8_flags(s, send, tmpbuf, &upper_len, 0); + uv = toUPPER_utf8_flags_(s, send, tmpbuf, &upper_len, 0); #endif if ( UNLIKELY(uv == GREEK_CAPITAL_LETTER_IOTA) && memBEGINs(s, this_len, COMBINING_GREEK_YPOGEGRAMMENI_UTF8)) From 8ace9e8437adc726d17c1e7f9b37b6ab6553a1d4 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:30:51 -0600 Subject: [PATCH 58/87] Convert _PERL_STRLEN_ROUNDUP_UNCHECKED to legal name --- handy.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/handy.h b/handy.h index 4d705c1a9d5c..6c04f58dee14 100644 --- a/handy.h +++ b/handy.h @@ -2693,7 +2693,7 @@ These each call C for catching access to freed memory. #define MEM_SIZE_MAX ((MEM_SIZE)-1) -#define _PERL_STRLEN_ROUNDUP_UNCHECKED(n) (((n) - 1 + PERL_STRLEN_ROUNDUP_QUANTUM) & ~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM - 1)) +#define PERL_STRLEN_ROUNDUP_UNCHECKED_(n) (((n) - 1 + PERL_STRLEN_ROUNDUP_QUANTUM) & ~((MEM_SIZE)PERL_STRLEN_ROUNDUP_QUANTUM - 1)) #ifdef PERL_MALLOC_WRAP @@ -2748,7 +2748,7 @@ These each call C for catching access to freed memory. # define MEM_WRAP_CHECK_(n,t) MEM_WRAP_CHECK(n,t), -# define PERL_STRLEN_ROUNDUP(n) ((void)(((n) > MEM_SIZE_MAX - 2 * PERL_STRLEN_ROUNDUP_QUANTUM) ? (croak_memory_wrap(),0) : 0), _PERL_STRLEN_ROUNDUP_UNCHECKED(n)) +# define PERL_STRLEN_ROUNDUP(n) ((void)(((n) > MEM_SIZE_MAX - 2 * PERL_STRLEN_ROUNDUP_QUANTUM) ? (croak_memory_wrap(),0) : 0), PERL_STRLEN_ROUNDUP_UNCHECKED_(n)) #else # define MEM_WRAP_CHECK(n,t) @@ -2756,7 +2756,7 @@ These each call C for catching access to freed memory. # define MEM_WRAP_CHECK_s(n,t,a) # define MEM_WRAP_CHECK_(n,t) -# define PERL_STRLEN_ROUNDUP(n) _PERL_STRLEN_ROUNDUP_UNCHECKED(n) +# define PERL_STRLEN_ROUNDUP(n) PERL_STRLEN_ROUNDUP_UNCHECKED_(n) #endif From 1164967a789a91277ee6c0040c77b5be6a831c9a Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:32:10 -0600 Subject: [PATCH 59/87] Convert _MEM_WRAP_NEEDS_RUNTIME_CHECK to legal name --- handy.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/handy.h b/handy.h index 6c04f58dee14..660ad82d9f30 100644 --- a/handy.h +++ b/handy.h @@ -2708,13 +2708,13 @@ These each call C for catching access to freed memory. */ -# define _MEM_WRAP_NEEDS_RUNTIME_CHECK(n,t) \ +# define MEM_WRAP_NEEDS_RUNTIME_CHECK_(n,t) \ ( sizeof(MEM_SIZE) < sizeof(n) \ || sizeof(t) > ((MEM_SIZE)1 << 8*(sizeof(MEM_SIZE) - sizeof(n)))) /* This is written in a slightly odd way to avoid various spurious * compiler warnings. We *want* to write the expression as - * _MEM_WRAP_NEEDS_RUNTIME_CHECK(n,t) && (n > C) + * MEM_WRAP_NEEDS_RUNTIME_CHECK_(n,t) && (n > C) * (for some compile-time constant C), but even when the LHS * constant-folds to false at compile-time, g++ insists on emitting * warnings about the RHS (e.g. "comparison is always false"), so instead @@ -2730,7 +2730,7 @@ These each call C for catching access to freed memory. */ # define _MEM_WRAP_WILL_WRAP(n,t) \ - ((_MEM_WRAP_NEEDS_RUNTIME_CHECK(n,t) ? (MEM_SIZE)(n) : \ + ((MEM_WRAP_NEEDS_RUNTIME_CHECK_(n,t) ? (MEM_SIZE)(n) : \ MEM_SIZE_MAX/sizeof(t)) > MEM_SIZE_MAX/sizeof(t)) # define MEM_WRAP_CHECK(n,t) \ From 33cabb814971203c9bdea0b63b047aadda47a482 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:33:09 -0600 Subject: [PATCH 60/87] Convert _MEM_WRAP_WILL_WRAP to legal name --- handy.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/handy.h b/handy.h index 660ad82d9f30..b522d7d1bb1f 100644 --- a/handy.h +++ b/handy.h @@ -2729,21 +2729,21 @@ These each call C for catching access to freed memory. * for X and hope that nothing else whines. */ -# define _MEM_WRAP_WILL_WRAP(n,t) \ +# define MEM_WRAP_WILL_WRAP_(n,t) \ ((MEM_WRAP_NEEDS_RUNTIME_CHECK_(n,t) ? (MEM_SIZE)(n) : \ MEM_SIZE_MAX/sizeof(t)) > MEM_SIZE_MAX/sizeof(t)) # define MEM_WRAP_CHECK(n,t) \ - (void)(UNLIKELY(_MEM_WRAP_WILL_WRAP(n,t)) \ + (void)(UNLIKELY(MEM_WRAP_WILL_WRAP_(n,t)) \ && (croak_memory_wrap(),0)) # define MEM_WRAP_CHECK_1(n,t,a) \ - (void)(UNLIKELY(_MEM_WRAP_WILL_WRAP(n,t)) \ + (void)(UNLIKELY(MEM_WRAP_WILL_WRAP_(n,t)) \ && (Perl_croak_nocontext("%s",(a)),0)) /* "a" arg must be a string literal */ # define MEM_WRAP_CHECK_s(n,t,a) \ - ( (void) (UNLIKELY(_MEM_WRAP_WILL_WRAP(n,t)) \ + ( (void) (UNLIKELY(MEM_WRAP_WILL_WRAP_(n,t)) \ && (Perl_croak_nocontext(ASSERT_IS_LITERAL(a)), 0))) # define MEM_WRAP_CHECK_(n,t) MEM_WRAP_CHECK(n,t), From 73a31b6a1f6a17c0ac5b42e02ef2af7c34cba318 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:58:38 -0600 Subject: [PATCH 61/87] pp_ctl.c Convert _arg to legal name --- pp_ctl.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/pp_ctl.c b/pp_ctl.c index dd4ee7eed6ce..972a187a618d 100644 --- a/pp_ctl.c +++ b/pp_ctl.c @@ -6468,9 +6468,9 @@ PP(pp_break) } static void -_invoke_defer_block(pTHX_ U8 type, void *_arg) +_invoke_defer_block(pTHX_ U8 type, void * arg_) { - OP *start = (OP *)_arg; + OP *start = (OP *) arg_; #ifdef DEBUGGING I32 was_cxstack_ix = cxstack_ix; #endif @@ -6541,15 +6541,15 @@ _invoke_defer_block(pTHX_ U8 type, void *_arg) } static void -invoke_defer_block(pTHX_ void *_arg) +invoke_defer_block(pTHX_ void * arg_) { - _invoke_defer_block(aTHX_ CXt_DEFER, _arg); + _invoke_defer_block(aTHX_ CXt_DEFER, arg_); } static void -invoke_finally_block(pTHX_ void *_arg) +invoke_finally_block(pTHX_ void * arg_) { - _invoke_defer_block(aTHX_ CXt_DEFER|CXp_FINALLY, _arg); + _invoke_defer_block(aTHX_ CXt_DEFER|CXp_FINALLY, arg_); } PP(pp_pushdefer) From 070f1593fecfda4dabed7c85263aab199b733b16 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:00:07 -0600 Subject: [PATCH 62/87] pp_ctl.c Convert _invoke_defer_block to legal name --- pp_ctl.c | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/pp_ctl.c b/pp_ctl.c index 972a187a618d..5cfd919e6b6d 100644 --- a/pp_ctl.c +++ b/pp_ctl.c @@ -6468,7 +6468,7 @@ PP(pp_break) } static void -_invoke_defer_block(pTHX_ U8 type, void * arg_) +invoke_defer_block_(pTHX_ U8 type, void * arg_) { OP *start = (OP *) arg_; #ifdef DEBUGGING @@ -6543,13 +6543,13 @@ _invoke_defer_block(pTHX_ U8 type, void * arg_) static void invoke_defer_block(pTHX_ void * arg_) { - _invoke_defer_block(aTHX_ CXt_DEFER, arg_); + invoke_defer_block_(aTHX_ CXt_DEFER, arg_); } static void invoke_finally_block(pTHX_ void * arg_) { - _invoke_defer_block(aTHX_ CXt_DEFER|CXp_FINALLY, arg_); + invoke_defer_block_(aTHX_ CXt_DEFER|CXp_FINALLY, arg_); } PP(pp_pushdefer) From 9edca40946cc28ea15d4758a494c40211b6210f4 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:37:03 -0600 Subject: [PATCH 63/87] sv.h Convert _crash to legal name --- sv.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/sv.h b/sv.h index 0cf54703aeee..ed4df0269682 100644 --- a/sv.h +++ b/sv.h @@ -2676,19 +2676,19 @@ Evaluates C more than once. Sets C to 0 if C is false. # define SvOOK_offset(sv, offset) STMT_START { \ STATIC_ASSERT_STMT(sizeof(offset) == sizeof(STRLEN)); \ if (SvOOK(sv)) { \ - const U8 *_crash = (U8*)SvPVX_const(sv); \ - (offset) = *--_crash; \ + const U8 *crash_ = (U8*)SvPVX_const(sv); \ + (offset) = *--crash_; \ if (!(offset)) { \ - _crash -= sizeof(STRLEN); \ - Copy(_crash, (U8 *)&(offset), sizeof(STRLEN), U8); \ + crash_ -= sizeof(STRLEN); \ + Copy(crash_, (U8 *)&(offset), sizeof(STRLEN), U8); \ } \ { \ /* Validate the preceding buffer's sentinels to \ verify that no-one is using it. */ \ const U8 *const _bonk = (U8*)SvPVX_const(sv) - (offset);\ - while (_crash > _bonk) { \ - --_crash; \ - assert (*_crash == (U8)PTR2UV(_crash)); \ + while (crash_ > _bonk) { \ + --crash_; \ + assert (*crash_ == (U8)PTR2UV(crash_)); \ } \ } \ } else { \ From 50664807be132af778b6c05ae26a959f566b86be Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:37:32 -0600 Subject: [PATCH 64/87] sv.h Convert _bonk to legal name --- sv.h | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/sv.h b/sv.h index ed4df0269682..3c6ebcd6c9f2 100644 --- a/sv.h +++ b/sv.h @@ -2685,8 +2685,8 @@ Evaluates C more than once. Sets C to 0 if C is false. { \ /* Validate the preceding buffer's sentinels to \ verify that no-one is using it. */ \ - const U8 *const _bonk = (U8*)SvPVX_const(sv) - (offset);\ - while (crash_ > _bonk) { \ + const U8 *const bonk_ = (U8*)SvPVX_const(sv) - (offset);\ + while (crash_ > bonk_) { \ --crash_; \ assert (*crash_ == (U8)PTR2UV(crash_)); \ } \ From 8f0f0f8d1af100cbbd59183a1a9ddf3918acad5e Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:38:16 -0600 Subject: [PATCH 65/87] sv.h Convert _bmuseful to legal name --- sv.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/sv.h b/sv.h index 3c6ebcd6c9f2..cbf2145b8ece 100644 --- a/sv.h +++ b/sv.h @@ -1652,11 +1652,11 @@ only be used as part of a larger operation #if defined (DEBUGGING) && defined(PERL_USE_GCC_BRACE_GROUPS) # define BmUSEFUL(sv) \ - (*({ SV *const _bmuseful = MUTABLE_SV(sv); \ - assert(SvTYPE(_bmuseful) >= SVt_PVIV); \ - assert(SvVALID(_bmuseful)); \ - assert(!SvIOK(_bmuseful)); \ - &(((XPVIV*) SvANY(_bmuseful))->xiv_u.xivu_iv); \ + (*({ SV *const bmuseful_ = MUTABLE_SV(sv); \ + assert(SvTYPE(bmuseful_) >= SVt_PVIV); \ + assert(SvVALID(bmuseful_)); \ + assert(!SvIOK(bmuseful_)); \ + &(((XPVIV*) SvANY(bmuseful_))->xiv_u.xivu_iv); \ })) #else # define BmUSEFUL(sv) ((XPVIV*) SvANY(sv))->xiv_u.xivu_iv From 0941323cde8fe1ffd50d2eb44a9dc5a7453dc982 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:38:53 -0600 Subject: [PATCH 66/87] sv.h Convert _lEnGtH to legal name --- sv.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/sv.h b/sv.h index cbf2145b8ece..d39d18994494 100644 --- a/sv.h +++ b/sv.h @@ -1596,16 +1596,16 @@ L> before calling this. * is no smaller than the expected minimim allocation and that the given * size is rounded up to the closest PTRSIZE boundary. Depending on * per-malloc implementation, it might return the exact size that would - * be allocated for the specified _lEnGtH. If the return value from + * be allocated for the specified lEnGtH_. If the return value from * `expected_size` is not smaller than the current buffer allocation, * there is no point in calling SvPV_renew. */ #define SvPV_shrink_to_cur(sv) STMT_START { \ - const STRLEN _lEnGtH = SvCUR(sv) + 2; \ - const STRLEN _eXpEcT = expected_size(_lEnGtH); \ - if (SvLEN(sv) > _eXpEcT) \ - SvPV_renew(sv, _eXpEcT); \ + const STRLEN lEnGtH_ = SvCUR(sv) + 2; \ + const STRLEN eXpEcT_ = expected_size(lEnGtH_); \ + if (SvLEN(sv) > eXpEcT_) \ + SvPV_renew(sv, eXpEcT_); \ } STMT_END /* From c210ddbb1d98d8d0e8efb9736e62b69c35156076 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:40:40 -0600 Subject: [PATCH 67/87] sv.h Convert _svpvx to legal name --- sv.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/sv.h b/sv.h index d39d18994494..8e0d261b5dd0 100644 --- a/sv.h +++ b/sv.h @@ -1375,12 +1375,12 @@ object type. Exposed to perl code via Internals::SvREADONLY(). # if defined (DEBUGGING) && defined(PERL_USE_GCC_BRACE_GROUPS) /* These get expanded inside other macros that already use a variable _sv */ # define SvPVX(sv) \ - (*({ SV *const _svpvx = MUTABLE_SV(sv); \ - assert(PL_valid_types_PVX[SvTYPE(_svpvx) & SVt_MASK]); \ - assert(!isGV_with_GP(_svpvx)); \ - assert(!(SvTYPE(_svpvx) == SVt_PVIO \ - && !(IoFLAGS(_svpvx) & IOf_FAKE_DIRP))); \ - &((_svpvx)->sv_u.svu_pv); \ + (*({ SV *const svpvx_ = MUTABLE_SV(sv); \ + assert(PL_valid_types_PVX[SvTYPE(svpvx_) & SVt_MASK]); \ + assert(!isGV_with_GP(svpvx_)); \ + assert(!(SvTYPE(svpvx_) == SVt_PVIO \ + && !(IoFLAGS(svpvx_) & IOf_FAKE_DIRP))); \ + &((svpvx_)->sv_u.svu_pv); \ })) # ifdef PERL_CORE # define SvCUR(sv) \ From aaf1b35353d809c025b74fde2f2cb29b818734f2 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:41:15 -0600 Subject: [PATCH 68/87] sv.h Convert _svcur to legal name --- sv.h | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/sv.h b/sv.h index 8e0d261b5dd0..7976fb93acab 100644 --- a/sv.h +++ b/sv.h @@ -1384,21 +1384,21 @@ object type. Exposed to perl code via Internals::SvREADONLY(). })) # ifdef PERL_CORE # define SvCUR(sv) \ - ({ const SV *const _svcur = (const SV *)(sv); \ - assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK]); \ - assert(!isGV_with_GP(_svcur)); \ - assert(!(SvTYPE(_svcur) == SVt_PVIO \ - && !(IoFLAGS(_svcur) & IOf_FAKE_DIRP))); \ - (((XPV*) MUTABLE_PTR(SvANY(_svcur)))->xpv_cur); \ + ({ const SV *const svcur_ = (const SV *)(sv); \ + assert(PL_valid_types_PVX[SvTYPE(svcur_) & SVt_MASK]); \ + assert(!isGV_with_GP(svcur_)); \ + assert(!(SvTYPE(svcur_) == SVt_PVIO \ + && !(IoFLAGS(svcur_) & IOf_FAKE_DIRP))); \ + (((XPV*) MUTABLE_PTR(SvANY(svcur_)))->xpv_cur); \ }) # else # define SvCUR(sv) \ - (*({ const SV *const _svcur = (const SV *)(sv); \ - assert(PL_valid_types_PVX[SvTYPE(_svcur) & SVt_MASK]); \ - assert(!isGV_with_GP(_svcur)); \ - assert(!(SvTYPE(_svcur) == SVt_PVIO \ - && !(IoFLAGS(_svcur) & IOf_FAKE_DIRP))); \ - &(((XPV*) MUTABLE_PTR(SvANY(_svcur)))->xpv_cur); \ + (*({ const SV *const svcur_ = (const SV *)(sv); \ + assert(PL_valid_types_PVX[SvTYPE(svcur_) & SVt_MASK]); \ + assert(!isGV_with_GP(svcur_)); \ + assert(!(SvTYPE(svcur_) == SVt_PVIO \ + && !(IoFLAGS(svcur_) & IOf_FAKE_DIRP))); \ + &(((XPV*) MUTABLE_PTR(SvANY(svcur_)))->xpv_cur); \ })) # endif # define SvIVX(sv) \ From 2eeac2e936ada90038b1b5853e34348ec6ee8836 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:41:59 -0600 Subject: [PATCH 69/87] sv.h Convert _svivx to legal name --- sv.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sv.h b/sv.h index 7976fb93acab..96d1ed4d94a9 100644 --- a/sv.h +++ b/sv.h @@ -1402,10 +1402,10 @@ object type. Exposed to perl code via Internals::SvREADONLY(). })) # endif # define SvIVX(sv) \ - (*({ const SV *const _svivx = (const SV *)(sv); \ - assert(PL_valid_types_IVX[SvTYPE(_svivx) & SVt_MASK]); \ - assert(!isGV_with_GP(_svivx)); \ - &(((XPVIV*) MUTABLE_PTR(SvANY(_svivx)))->xiv_iv); \ + (*({ const SV *const svivx_ = (const SV *)(sv); \ + assert(PL_valid_types_IVX[SvTYPE(svivx_) & SVt_MASK]); \ + assert(!isGV_with_GP(svivx_)); \ + &(((XPVIV*) MUTABLE_PTR(SvANY(svivx_)))->xiv_iv); \ })) # define SvUVX(sv) \ (*({ const SV *const _svuvx = (const SV *)(sv); \ From ac7a3a89fe92ba28c4504a83dd1ae85a0648351d Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:42:38 -0600 Subject: [PATCH 70/87] sv.h Convert _svrv to legal name --- sv.h | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/sv.h b/sv.h index 96d1ed4d94a9..cc06c470a899 100644 --- a/sv.h +++ b/sv.h @@ -1420,20 +1420,20 @@ object type. Exposed to perl code via Internals::SvREADONLY(). &(((XPVNV*) MUTABLE_PTR(SvANY(_svnvx)))->xnv_u.xnv_nv); \ })) # define SvRV(sv) \ - (*({ SV *const _svrv = MUTABLE_SV(sv); \ - assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]); \ - assert(!isGV_with_GP(_svrv)); \ - assert(!(SvTYPE(_svrv) == SVt_PVIO \ - && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP))); \ - &((_svrv)->sv_u.svu_rv); \ + (*({ SV *const svrv_ = MUTABLE_SV(sv); \ + assert(PL_valid_types_RV[SvTYPE(svrv_) & SVt_MASK]); \ + assert(!isGV_with_GP(svrv_)); \ + assert(!(SvTYPE(svrv_) == SVt_PVIO \ + && !(IoFLAGS(svrv_) & IOf_FAKE_DIRP))); \ + &((svrv_)->sv_u.svu_rv); \ })) # define SvRV_const(sv) \ - ({ const SV *const _svrv = (const SV *)(sv); \ - assert(PL_valid_types_RV[SvTYPE(_svrv) & SVt_MASK]); \ - assert(!isGV_with_GP(_svrv)); \ - assert(!(SvTYPE(_svrv) == SVt_PVIO \ - && !(IoFLAGS(_svrv) & IOf_FAKE_DIRP))); \ - (_svrv)->sv_u.svu_rv; \ + ({ const SV *const svrv_ = (const SV *)(sv); \ + assert(PL_valid_types_RV[SvTYPE(svrv_) & SVt_MASK]); \ + assert(!isGV_with_GP(svrv_)); \ + assert(!(SvTYPE(svrv_) == SVt_PVIO \ + && !(IoFLAGS(svrv_) & IOf_FAKE_DIRP))); \ + (svrv_)->sv_u.svu_rv; \ }) # define SvMAGIC(sv) \ (*({ const SV *const _svmagic = (const SV *)(sv); \ From c6008dbb50b6579a27ead704eb1911db77b73c02 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:43:22 -0600 Subject: [PATCH 71/87] sv.h Convert _svmagic to legal name --- sv.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sv.h b/sv.h index cc06c470a899..51e0371b5bd8 100644 --- a/sv.h +++ b/sv.h @@ -1436,9 +1436,9 @@ object type. Exposed to perl code via Internals::SvREADONLY(). (svrv_)->sv_u.svu_rv; \ }) # define SvMAGIC(sv) \ - (*({ const SV *const _svmagic = (const SV *)(sv); \ - assert(SvTYPE(_svmagic) >= SVt_PVMG); \ - &(((XPVMG*) MUTABLE_PTR(SvANY(_svmagic)))->xmg_u.xmg_magic); \ + (*({ const SV *const svmagic_ = (const SV *)(sv); \ + assert(SvTYPE(svmagic_) >= SVt_PVMG); \ + &(((XPVMG*) MUTABLE_PTR(SvANY(svmagic_)))->xmg_u.xmg_magic); \ })) # define SvSTASH(sv) \ (*({ const SV *const _svstash = (const SV *)(sv); \ From ed84f45df0eb0125139c45dead736fc1e454f86e Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:43:50 -0600 Subject: [PATCH 72/87] sv.h Convert _svstash to legal name --- sv.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sv.h b/sv.h index 51e0371b5bd8..b875c8572860 100644 --- a/sv.h +++ b/sv.h @@ -1441,9 +1441,9 @@ object type. Exposed to perl code via Internals::SvREADONLY(). &(((XPVMG*) MUTABLE_PTR(SvANY(svmagic_)))->xmg_u.xmg_magic); \ })) # define SvSTASH(sv) \ - (*({ const SV *const _svstash = (const SV *)(sv); \ - assert(SvTYPE(_svstash) >= SVt_PVMG); \ - &(((XPVMG*) MUTABLE_PTR(SvANY(_svstash)))->xmg_stash); \ + (*({ const SV *const svstash_ = (const SV *)(sv); \ + assert(SvTYPE(svstash_) >= SVt_PVMG); \ + &(((XPVMG*) MUTABLE_PTR(SvANY(svstash_)))->xmg_stash); \ })) # else /* Below is not DEBUGGING or can't use brace groups */ # define SvPVX(sv) ((sv)->sv_u.svu_pv) From 2ca7eaba056ec84e301d462675c2bc5a61fe7a8b Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:44:38 -0600 Subject: [PATCH 73/87] sv.h Convert _svuvx to legal name --- sv.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sv.h b/sv.h index b875c8572860..1e452d74483d 100644 --- a/sv.h +++ b/sv.h @@ -1408,10 +1408,10 @@ object type. Exposed to perl code via Internals::SvREADONLY(). &(((XPVIV*) MUTABLE_PTR(SvANY(svivx_)))->xiv_iv); \ })) # define SvUVX(sv) \ - (*({ const SV *const _svuvx = (const SV *)(sv); \ - assert(PL_valid_types_IVX[SvTYPE(_svuvx) & SVt_MASK]); \ - assert(!isGV_with_GP(_svuvx)); \ - &(((XPVUV*) MUTABLE_PTR(SvANY(_svuvx)))->xuv_uv); \ + (*({ const SV *const svuvx_ = (const SV *)(sv); \ + assert(PL_valid_types_IVX[SvTYPE(svuvx_) & SVt_MASK]); \ + assert(!isGV_with_GP(svuvx_)); \ + &(((XPVUV*) MUTABLE_PTR(SvANY(svuvx_)))->xuv_uv); \ })) # define SvNVX(sv) \ (*({ const SV *const _svnvx = (const SV *)(sv); \ From a2bff4c49ca6b8f9b160545b3e33c9913e8fc74b Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:44:59 -0600 Subject: [PATCH 74/87] sv.h Convert _svnvx to legal name --- sv.h | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/sv.h b/sv.h index 1e452d74483d..d141cfb512a2 100644 --- a/sv.h +++ b/sv.h @@ -1414,10 +1414,10 @@ object type. Exposed to perl code via Internals::SvREADONLY(). &(((XPVUV*) MUTABLE_PTR(SvANY(svuvx_)))->xuv_uv); \ })) # define SvNVX(sv) \ - (*({ const SV *const _svnvx = (const SV *)(sv); \ - assert(PL_valid_types_NVX[SvTYPE(_svnvx) & SVt_MASK]); \ - assert(!isGV_with_GP(_svnvx)); \ - &(((XPVNV*) MUTABLE_PTR(SvANY(_svnvx)))->xnv_u.xnv_nv); \ + (*({ const SV *const svnvx_ = (const SV *)(sv); \ + assert(PL_valid_types_NVX[SvTYPE(svnvx_) & SVt_MASK]); \ + assert(!isGV_with_GP(svnvx_)); \ + &(((XPVNV*) MUTABLE_PTR(SvANY(svnvx_)))->xnv_u.xnv_nv); \ })) # define SvRV(sv) \ (*({ SV *const svrv_ = MUTABLE_SV(sv); \ From 5e02639947dd592fb0d47f77983dbd57b4e29891 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:46:20 -0600 Subject: [PATCH 75/87] sv.h Convert _svtail to legal name --- sv.h | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/sv.h b/sv.h index d141cfb512a2..62bb30e01a13 100644 --- a/sv.h +++ b/sv.h @@ -1321,15 +1321,15 @@ object type. Exposed to perl code via Internals::SvREADONLY(). #if defined (DEBUGGING) && defined(PERL_USE_GCC_BRACE_GROUPS) -# define SvTAIL(sv) ({ const SV *const _svtail = (const SV *)(sv); \ - assert(SvTYPE(_svtail) != SVt_PVAV); \ - assert(SvTYPE(_svtail) != SVt_PVHV); \ - assert(!(SvFLAGS(_svtail) & (SVf_NOK|SVp_NOK))); \ - assert(SvVALID(_svtail)); \ - ((XPVNV*)SvANY(_svtail))->xnv_u.xnv_bm_tail; \ +# define SvTAIL(sv) ({ const SV *const svtail_ = (const SV *)(sv); \ + assert(SvTYPE(svtail_) != SVt_PVAV); \ + assert(SvTYPE(svtail_) != SVt_PVHV); \ + assert(!(SvFLAGS(svtail_) & (SVf_NOK|SVp_NOK))); \ + assert(SvVALID(svtail_)); \ + ((XPVNV*)SvANY(svtail_))->xnv_u.xnv_bm_tail; \ }) #else -# define SvTAIL(_svtail) (((XPVNV*)SvANY(_svtail))->xnv_u.xnv_bm_tail) +# define SvTAIL(svtail_) (((XPVNV*)SvANY(svtail_))->xnv_u.xnv_bm_tail) #endif /* Does the SV have a Boyer-Moore table attached as magic? From 04668fd5fee2fc942260d6885df5787e7ec18db6 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 16:46:58 -0600 Subject: [PATCH 76/87] sv.h Convert _svvalid to legal name --- sv.h | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/sv.h b/sv.h index 62bb30e01a13..0333dd759599 100644 --- a/sv.h +++ b/sv.h @@ -1334,12 +1334,12 @@ object type. Exposed to perl code via Internals::SvREADONLY(). /* Does the SV have a Boyer-Moore table attached as magic? * 'VALID' is a poor name, but is kept for historical reasons. */ -#define SvVALID(_svvalid) ( \ - SvPOKp(_svvalid) \ - && SvSMAGICAL(_svvalid) \ - && SvMAGIC(_svvalid) \ - && (SvMAGIC(_svvalid)->mg_type == PERL_MAGIC_bm \ - || mg_find(_svvalid, PERL_MAGIC_bm)) \ +#define SvVALID(svvalid_) ( \ + SvPOKp(svvalid_) \ + && SvSMAGICAL(svvalid_) \ + && SvMAGIC(svvalid_) \ + && (SvMAGIC(svvalid_)->mg_type == PERL_MAGIC_bm \ + || mg_find(svvalid_, PERL_MAGIC_bm)) \ ) #define SvRVx(sv) SvRV(sv) From 7ab787ce29282979fc0d9e6e7cbd0d104b0ff5f9 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:03:59 -0600 Subject: [PATCH 77/87] sv.h Convert _xivu to legal name --- sv.h | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/sv.h b/sv.h index 0333dd759599..bf1a899a684f 100644 --- a/sv.h +++ b/sv.h @@ -556,7 +556,7 @@ union _xnvu { bool xnv_bm_tail; /* an SvVALID (BM) SV has an implicit "\n" */ }; -union _xivu { +union xivu_ { IV xivu_iv; /* integer value */ UV xivu_uv; HEK * xivu_namehek; /* xpvlv, xpvgv: GvNAME */ @@ -575,34 +575,34 @@ struct xpv { struct xpviv { _XPV_HEAD; - union _xivu xiv_u; + union xivu_ xiv_u; }; #define xiv_iv xiv_u.xivu_iv struct xpvuv { _XPV_HEAD; - union _xivu xuv_u; + union xivu_ xuv_u; }; #define xuv_uv xuv_u.xivu_uv struct xpvnv { _XPV_HEAD; - union _xivu xiv_u; + union xivu_ xiv_u; union _xnvu xnv_u; }; /* This structure must match the beginning of struct xpvhv in hv.h. */ struct xpvmg { _XPV_HEAD; - union _xivu xiv_u; + union xivu_ xiv_u; union _xnvu xnv_u; }; struct xpvlv { _XPV_HEAD; - union _xivu xiv_u; + union xivu_ xiv_u; union _xnvu xnv_u; union { STRLEN xlvu_targoff; @@ -634,7 +634,7 @@ struct xpvinvlist { struct xpvgv { _XPV_HEAD; - union _xivu xiv_u; + union xivu_ xiv_u; union _xnvu xnv_u; }; @@ -676,7 +676,7 @@ struct xpvfm { struct xpvio { _XPV_HEAD; - union _xivu xiv_u; + union xivu_ xiv_u; /* ifp and ofp are normally the same, but sockets need separate streams */ PerlIO * xio_ofp; /* Cray addresses everything by word boundaries (64 bits) and From 537f3c53e92387627a10b4522c10c29debb61657 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:05:21 -0600 Subject: [PATCH 78/87] Convert union _xmgu to legal name --- av.h | 2 +- hv.h | 4 ++-- sv.h | 6 +++--- 3 files changed, 6 insertions(+), 6 deletions(-) diff --git a/av.h b/av.h index 5b7d0c4ff329..7471f116e154 100644 --- a/av.h +++ b/av.h @@ -10,7 +10,7 @@ struct xpvav { HV* xmg_stash; /* class package */ - union _xmgu xmg_u; + union xmgu_ xmg_u; SSize_t xav_fill; /* Index of last element present */ SSize_t xav_max; /* max index for which array has space */ SV** xav_alloc; /* pointer to beginning of C array of SVs */ diff --git a/hv.h b/hv.h index ae4901bada6e..bcd0c2bffe59 100644 --- a/hv.h +++ b/hv.h @@ -159,14 +159,14 @@ struct xpvhv_aux { /* This structure must match the beginning of struct xpvmg in sv.h. */ struct xpvhv { HV* xmg_stash; /* class package */ - union _xmgu xmg_u; + union xmgu_ xmg_u; STRLEN xhv_keys; /* total keys, including placeholders */ STRLEN xhv_max; /* subscript of last element of xhv_array */ }; struct xpvhv_with_aux { HV *xmg_stash; /* class package */ - union _xmgu xmg_u; + union xmgu_ xmg_u; STRLEN xhv_keys; /* total keys, including placeholders */ STRLEN xhv_max; /* subscript of last element of xhv_array */ struct xpvhv_aux xhv_aux; diff --git a/sv.h b/sv.h index bf1a899a684f..5032573aac96 100644 --- a/sv.h +++ b/sv.h @@ -540,7 +540,7 @@ These guys don't need the curly blocks #define _XPV_HEAD \ HV* xmg_stash; /* class package */ \ - union _xmgu xmg_u; \ + union xmgu_ xmg_u; \ STRLEN xpv_cur; /* length of svu_pv as a C string */ \ union { \ STRLEN xpvlenu_len; /* allocated size */ \ @@ -564,7 +564,7 @@ union xivu_ { }; -union _xmgu { +union xmgu_ { MAGIC* xmg_magic; /* linked list of magicalness */ STRLEN xmg_hash_index; /* used while freeing hash entries */ }; @@ -720,7 +720,7 @@ struct xpvio { struct xobject { HV* xmg_stash; - union _xmgu xmg_u; + union xmgu_ xmg_u; SSize_t xobject_maxfield; SSize_t xobject_iter_sv_at; /* this is only used by Perl_sv_clear() */ SV** xobject_fields; From 93cf6a58a672a4c37c6b946c6fe57097323ed851 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:08:00 -0600 Subject: [PATCH 79/87] sv.h Convert _xnvu to legal name --- sv.h | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/sv.h b/sv.h index 5032573aac96..4b1edbed60ec 100644 --- a/sv.h +++ b/sv.h @@ -549,7 +549,7 @@ These guys don't need the curly blocks #define xpv_len xpv_len_u.xpvlenu_len -union _xnvu { +union xnvu_ { NV xnv_nv; /* numeric value, if any */ HV * xgv_stash; line_t xnv_lines; /* used internally by S_scan_subst() */ @@ -590,20 +590,20 @@ struct xpvuv { struct xpvnv { _XPV_HEAD; union xivu_ xiv_u; - union _xnvu xnv_u; + union xnvu_ xnv_u; }; /* This structure must match the beginning of struct xpvhv in hv.h. */ struct xpvmg { _XPV_HEAD; union xivu_ xiv_u; - union _xnvu xnv_u; + union xnvu_ xnv_u; }; struct xpvlv { _XPV_HEAD; union xivu_ xiv_u; - union _xnvu xnv_u; + union xnvu_ xnv_u; union { STRLEN xlvu_targoff; SSize_t xlvu_stargoff; @@ -635,7 +635,7 @@ struct xpvinvlist { struct xpvgv { _XPV_HEAD; union xivu_ xiv_u; - union _xnvu xnv_u; + union xnvu_ xnv_u; }; typedef U32 cv_flags_t; From 9834098d6ce11d715a31f7cc651adbe816cad78d Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:12:14 -0600 Subject: [PATCH 80/87] sv.h Convert _NV_BODYLESS_UNION to legal name --- sv.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sv.h b/sv.h index 4b1edbed60ec..aa20a036dc03 100644 --- a/sv.h +++ b/sv.h @@ -211,9 +211,9 @@ typedef struct hek HEK; U32 sv_flags /* what we are */ #if NVSIZE <= IVSIZE -# define _NV_BODYLESS_UNION NV svu_nv; +# define NV_BODYLESS_UNION_ NV svu_nv; #else -# define _NV_BODYLESS_UNION +# define NV_BODYLESS_UNION_ #endif #define _SV_HEAD_UNION \ @@ -221,7 +221,7 @@ typedef struct hek HEK; char* svu_pv; /* pointer to malloced string */ \ IV svu_iv; \ UV svu_uv; \ - _NV_BODYLESS_UNION \ + NV_BODYLESS_UNION_ \ SV* svu_rv; /* pointer to another SV */ \ SV** svu_array; \ HE** svu_hash; \ From cbd4edb0da05de6f2880510146717fcf10c048c5 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:15:36 -0600 Subject: [PATCH 81/87] sv.h Convert _SV_HEAD_DEBUG to legal name --- sv.h | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/sv.h b/sv.h index aa20a036dc03..8487a0f7d845 100644 --- a/sv.h +++ b/sv.h @@ -228,10 +228,10 @@ typedef struct hek HEK; GP* svu_gp; \ PerlIO *svu_fp; \ } sv_u \ - _SV_HEAD_DEBUG + SV_HEAD_DEBUG_ #ifdef DEBUG_LEAKING_SCALARS -#define _SV_HEAD_DEBUG ;\ +#define SV_HEAD_DEBUG_ ;\ PERL_BITFIELD32 sv_debug_optype:9; /* the type of OP that allocated us */ \ PERL_BITFIELD32 sv_debug_inpad:1; /* was allocated in a pad for an OP */ \ PERL_BITFIELD32 sv_debug_line:16; /* the line where we were allocated */ \ @@ -239,7 +239,7 @@ typedef struct hek HEK; char * sv_debug_file; /* the file where we were allocated */ \ SV * sv_debug_parent /* what we were cloned from (ithreads)*/ #else -#define _SV_HEAD_DEBUG +#define SV_HEAD_DEBUG_ #endif struct STRUCT_SV { /* struct sv { */ From 9693fc57bff4c084b1f2a8cc45f70715a14ca982 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:18:14 -0600 Subject: [PATCH 82/87] sv.h Convert _SV_HEAD_UNION to legal name --- sv.h | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/sv.h b/sv.h index 8487a0f7d845..a0650c0936a9 100644 --- a/sv.h +++ b/sv.h @@ -216,7 +216,7 @@ typedef struct hek HEK; # define NV_BODYLESS_UNION_ #endif -#define _SV_HEAD_UNION \ +#define SV_HEAD_UNION_ \ union { \ char* svu_pv; /* pointer to malloced string */ \ IV svu_iv; \ @@ -244,51 +244,51 @@ typedef struct hek HEK; struct STRUCT_SV { /* struct sv { */ _SV_HEAD(void*); - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; struct gv { _SV_HEAD(XPVGV*); /* pointer to xpvgv body */ - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; struct cv { _SV_HEAD(XPVCV*); /* pointer to xpvcv body */ - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; struct av { _SV_HEAD(XPVAV*); /* pointer to xpvav body */ - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; struct hv { _SV_HEAD(XPVHV*); /* pointer to xpvhv body */ - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; struct io { _SV_HEAD(XPVIO*); /* pointer to xpvio body */ - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; struct p5rx { _SV_HEAD(struct regexp*); /* pointer to regexp body */ - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; struct invlist { _SV_HEAD(XINVLIST*); /* pointer to xpvinvlist body */ - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; struct object { _SV_HEAD(XPVOBJ*); /* pointer to xobject body */ - _SV_HEAD_UNION; + SV_HEAD_UNION_; }; #undef _SV_HEAD -#undef _SV_HEAD_UNION /* ensure no pollution */ +#undef SV_HEAD_UNION_ /* ensure no pollution */ /* =for apidoc_section $SV From cf1b5870b957e517bf7796b3c47fd961647384aa Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:18:53 -0600 Subject: [PATCH 83/87] sv.h Convert _SV_HEAD to legal name --- sv.h | 22 +++++++++++----------- 1 file changed, 11 insertions(+), 11 deletions(-) diff --git a/sv.h b/sv.h index a0650c0936a9..11af19b7f34c 100644 --- a/sv.h +++ b/sv.h @@ -205,7 +205,7 @@ typedef struct hek HEK; /* Using C's structural equivalence to help emulate C++ inheritance here... */ /* start with 2 sv-head building blocks */ -#define _SV_HEAD(ptrtype) \ +#define SV_HEAD_(ptrtype) \ ptrtype sv_any; /* pointer to body */ \ U32 sv_refcnt; /* how many references to us */ \ U32 sv_flags /* what we are */ @@ -243,51 +243,51 @@ typedef struct hek HEK; #endif struct STRUCT_SV { /* struct sv { */ - _SV_HEAD(void*); + SV_HEAD_(void*); SV_HEAD_UNION_; }; struct gv { - _SV_HEAD(XPVGV*); /* pointer to xpvgv body */ + SV_HEAD_(XPVGV*); /* pointer to xpvgv body */ SV_HEAD_UNION_; }; struct cv { - _SV_HEAD(XPVCV*); /* pointer to xpvcv body */ + SV_HEAD_(XPVCV*); /* pointer to xpvcv body */ SV_HEAD_UNION_; }; struct av { - _SV_HEAD(XPVAV*); /* pointer to xpvav body */ + SV_HEAD_(XPVAV*); /* pointer to xpvav body */ SV_HEAD_UNION_; }; struct hv { - _SV_HEAD(XPVHV*); /* pointer to xpvhv body */ + SV_HEAD_(XPVHV*); /* pointer to xpvhv body */ SV_HEAD_UNION_; }; struct io { - _SV_HEAD(XPVIO*); /* pointer to xpvio body */ + SV_HEAD_(XPVIO*); /* pointer to xpvio body */ SV_HEAD_UNION_; }; struct p5rx { - _SV_HEAD(struct regexp*); /* pointer to regexp body */ + SV_HEAD_(struct regexp*); /* pointer to regexp body */ SV_HEAD_UNION_; }; struct invlist { - _SV_HEAD(XINVLIST*); /* pointer to xpvinvlist body */ + SV_HEAD_(XINVLIST*); /* pointer to xpvinvlist body */ SV_HEAD_UNION_; }; struct object { - _SV_HEAD(XPVOBJ*); /* pointer to xobject body */ + SV_HEAD_(XPVOBJ*); /* pointer to xobject body */ SV_HEAD_UNION_; }; -#undef _SV_HEAD +#undef SV_HEAD_ #undef SV_HEAD_UNION_ /* ensure no pollution */ /* From ca14aebc877709fb1e62409560b399c4138a413f Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:21:05 -0600 Subject: [PATCH 84/87] Convert _XPVCV_COMMON to legal name --- cv.h | 2 +- perl.h | 2 +- sv.h | 4 ++-- 3 files changed, 4 insertions(+), 4 deletions(-) diff --git a/cv.h b/cv.h index 6b8f6486c7dd..d5d0ce4b265c 100644 --- a/cv.h +++ b/cv.h @@ -12,7 +12,7 @@ struct xpvcv { _XPV_HEAD; - _XPVCV_COMMON; + XPVCV_COMMON_; }; /* diff --git a/perl.h b/perl.h index 41e1fc66c120..b5e2acca4c58 100644 --- a/perl.h +++ b/perl.h @@ -4553,7 +4553,7 @@ struct Perl_OpDumpContext; /* defined in sv.c, but also used in [ach]v.c */ #undef _XPV_HEAD #undef _XPVMG_HEAD -#undef _XPVCV_COMMON +#undef XPVCV_COMMON_ #include "parser.h" diff --git a/sv.h b/sv.h index 11af19b7f34c..cf8fcc70335c 100644 --- a/sv.h +++ b/sv.h @@ -640,7 +640,7 @@ struct xpvgv { typedef U32 cv_flags_t; -#define _XPVCV_COMMON \ +#define XPVCV_COMMON_ \ HV * xcv_stash; \ union { \ OP * xcv_start; \ @@ -670,7 +670,7 @@ typedef U32 cv_flags_t; struct xpvfm { _XPV_HEAD; - _XPVCV_COMMON; + XPVCV_COMMON_; }; From 9bb5d976633e9fa3401e341f917f84bf4150b8e9 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:21:51 -0600 Subject: [PATCH 85/87] Convert _XPVCV_HEAD to legal name --- cv.h | 2 +- perl.h | 2 +- pod/perlreapi.pod | 2 +- regexp.h | 2 +- sv.h | 22 +++++++++++----------- 5 files changed, 15 insertions(+), 15 deletions(-) diff --git a/cv.h b/cv.h index d5d0ce4b265c..5309fa3373b1 100644 --- a/cv.h +++ b/cv.h @@ -11,7 +11,7 @@ /* This structure must match the beginning of XPVFM in sv.h */ struct xpvcv { - _XPV_HEAD; + XPV_HEAD_; XPVCV_COMMON_; }; diff --git a/perl.h b/perl.h index b5e2acca4c58..42dd16b55dd4 100644 --- a/perl.h +++ b/perl.h @@ -4551,7 +4551,7 @@ struct Perl_OpDumpContext; #define my_lstat() my_lstat_flags(SV_GMAGIC) /* defined in sv.c, but also used in [ach]v.c */ -#undef _XPV_HEAD +#undef XPV_HEAD_ #undef _XPVMG_HEAD #undef XPVCV_COMMON_ diff --git a/pod/perlreapi.pod b/pod/perlreapi.pod index 89d5de1efcab..00dc87c6da67 100644 --- a/pod/perlreapi.pod +++ b/pod/perlreapi.pod @@ -643,7 +643,7 @@ values. /*---------------------------------------------------------------------- * Fields required for compatibility with SV types */ - _XPV_HEAD; + XPV_HEAD_; /*---------------------------------------------------------------------- * Operational fields diff --git a/regexp.h b/regexp.h index 57bc98a1adff..665fca86eeb9 100644 --- a/regexp.h +++ b/regexp.h @@ -139,7 +139,7 @@ typedef struct regexp { /*---------------------------------------------------------------------- * Fields required for compatibility with SV types */ - _XPV_HEAD; + XPV_HEAD_; /*---------------------------------------------------------------------- * Operational fields diff --git a/sv.h b/sv.h index cf8fcc70335c..5957e79288a5 100644 --- a/sv.h +++ b/sv.h @@ -538,7 +538,7 @@ These guys don't need the curly blocks #define SVprv_WEAKREF 0x80000000 /* Weak reference */ /* pad name vars only */ -#define _XPV_HEAD \ +#define XPV_HEAD_ \ HV* xmg_stash; /* class package */ \ union xmgu_ xmg_u; \ STRLEN xpv_cur; /* length of svu_pv as a C string */ \ @@ -570,38 +570,38 @@ union xmgu_ { }; struct xpv { - _XPV_HEAD; + XPV_HEAD_; }; struct xpviv { - _XPV_HEAD; + XPV_HEAD_; union xivu_ xiv_u; }; #define xiv_iv xiv_u.xivu_iv struct xpvuv { - _XPV_HEAD; + XPV_HEAD_; union xivu_ xuv_u; }; #define xuv_uv xuv_u.xivu_uv struct xpvnv { - _XPV_HEAD; + XPV_HEAD_; union xivu_ xiv_u; union xnvu_ xnv_u; }; /* This structure must match the beginning of struct xpvhv in hv.h. */ struct xpvmg { - _XPV_HEAD; + XPV_HEAD_; union xivu_ xiv_u; union xnvu_ xnv_u; }; struct xpvlv { - _XPV_HEAD; + XPV_HEAD_; union xivu_ xiv_u; union xnvu_ xnv_u; union { @@ -619,7 +619,7 @@ struct xpvlv { #define xlv_targoff xlv_targoff_u.xlvu_targoff struct xpvinvlist { - _XPV_HEAD; + XPV_HEAD_; IV prev_index; /* caches result of previous invlist_search() */ STRLEN iterator; /* Stores where we are in iterating */ bool is_offset; /* The data structure for all inversion lists @@ -633,7 +633,7 @@ struct xpvinvlist { /* This structure works in 2 ways - regular scalar, or GV with GP */ struct xpvgv { - _XPV_HEAD; + XPV_HEAD_; union xivu_ xiv_u; union xnvu_ xnv_u; }; @@ -669,13 +669,13 @@ typedef U32 cv_flags_t; /* This structure must match XPVCV in cv.h */ struct xpvfm { - _XPV_HEAD; + XPV_HEAD_; XPVCV_COMMON_; }; struct xpvio { - _XPV_HEAD; + XPV_HEAD_; union xivu_ xiv_u; /* ifp and ofp are normally the same, but sockets need separate streams */ PerlIO * xio_ofp; From a58c84dee5aa86bdd1a2f5d511c97b6ff6cf6ad3 Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 17:24:50 -0600 Subject: [PATCH 86/87] Convert _XPVMG_HEAD to legal name --- perl.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/perl.h b/perl.h index 42dd16b55dd4..9cbc04284ba6 100644 --- a/perl.h +++ b/perl.h @@ -4552,7 +4552,7 @@ struct Perl_OpDumpContext; /* defined in sv.c, but also used in [ach]v.c */ #undef XPV_HEAD_ -#undef _XPVMG_HEAD +#undef XPVMG_HEAD_ #undef XPVCV_COMMON_ #include "parser.h" From 8b2de4419b6b0042f81d41598ce806dc9265aebe Mon Sep 17 00:00:00 2001 From: Karl Williamson Date: Thu, 14 Aug 2025 14:47:11 -0600 Subject: [PATCH 87/87] dump.c: Convert _pv_display_for_dump to legal name No underscore is needed, as this is an internal macro. --- dump.c | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/dump.c b/dump.c index 58271d92f2f2..13ca1068c800 100644 --- a/dump.c +++ b/dump.c @@ -94,7 +94,7 @@ S_append_flags(pTHX_ SV *sv, U32 flags, const struct flag_to_name *start, PERL_PV_ESCAPE_NONASCII | PERL_PV_ESCAPE_DWIM \ | ((utf8) ? PERL_PV_ESCAPE_UNI : 0) ) -#define _pv_display_for_dump(dsv, pv, cur, len, pvlim) \ +#define pv_display_for_dump(dsv, pv, cur, len, pvlim) \ pv_display_flags(dsv, pv, cur, len, pvlim, PERL_PV_ESCAPE_DWIM_ALL_HEX) /* @@ -2438,7 +2438,7 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo PTR2UV(ptr)); if (SvOOK(sv)) { PerlIO_printf(file, "( %s . ) ", - _pv_display_for_dump(d, ptr - delta, delta, 0, + pv_display_for_dump(d, ptr - delta, delta, 0, pvlim)); } if (type == SVt_INVLIST) { @@ -2447,7 +2447,7 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo _invlist_dump(file, level, " ", sv); } else { - PerlIO_printf(file, "%s", _pv_display_for_dump(d, ptr, SvCUR(sv), + PerlIO_printf(file, "%s", pv_display_for_dump(d, ptr, SvCUR(sv), re ? 0 : SvLEN(sv), pvlim)); if (SvUTF8(sv)) /* the 6? \x{....} */ @@ -2749,7 +2749,7 @@ Perl_do_sv_dump(pTHX_ I32 level, PerlIO *file, SV *sv, I32 nest, I32 maxnest, bo keypv = SvPV_const(keysv, len); elt = HeVAL(he); - Perl_dump_indent(aTHX_ level+1, file, "Elt %s ", _pv_display_for_dump(d, keypv, len, 0, pvlim)); + Perl_dump_indent(aTHX_ level+1, file, "Elt %s ", pv_display_for_dump(d, keypv, len, 0, pvlim)); if (SvUTF8(keysv)) PerlIO_printf(file, "[UTF8 \"%s\"] ", sv_uni_display(d, keysv, 6 * SvCUR(keysv), UNI_DISPLAY_QQ)); if (HvEITER_get(hv) == he)