apply constexpr to certain private functions

jfmherokiller · jfmherokiller · commit d33ca7a7379f · 2023-11-04T22:54:35.000-06:00
diff --git a/include/st_utf_conv_priv.h b/include/st_utf_conv_priv.h
@@ -37,7 +37,7 @@ namespace _ST_PRIVATE
         latin1_out_of_range,
     };
 
-    inline void raise_conversion_error(conversion_error_t err)
+    constexpr void raise_conversion_error(conversion_error_t err)
     {
         switch (err) {
         case conversion_error_t::success:
@@ -176,21 +176,21 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline char32_t error_char(conversion_error_t value)
+    constexpr char32_t error_char(conversion_error_t value)
     {
         return static_cast<char32_t>(value) | 0x400000u;
     }
 
     ST_NODISCARD
-    inline conversion_error_t char_error(char32_t ch)
+    constexpr conversion_error_t char_error(char32_t ch)
     {
         return (ch & 0x400000u) != 0
                ? static_cast<conversion_error_t>(ch & ~0x400000u)
                : conversion_error_t::success;
     }
 
     ST_NODISCARD
-    inline char32_t extract_utf8(const unsigned char *&utf8, const unsigned char *end)
+    constexpr char32_t extract_utf8(const unsigned char *&utf8, const unsigned char *end)
     {
         char32_t bigch;
         if (*utf8 < 0x80) {
@@ -230,7 +230,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline size_t utf8_measure(char32_t ch)
+    constexpr size_t utf8_measure(char32_t ch)
     {
         if (ch < 0x80) {
             return 1;
@@ -247,7 +247,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline conversion_error_t write_utf8(char *&dest, char32_t ch)
+    constexpr conversion_error_t write_utf8(char *&dest, char32_t ch)
     {
         if (ch < 0x80) {
             *dest++ = static_cast<char>(ch);
@@ -272,7 +272,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline char32_t extract_utf16(const char16_t *&utf16, const char16_t *end)
+    constexpr char32_t extract_utf16(const char16_t *&utf16, const char16_t *end)
     {
         char32_t bigch;
         if (*utf16 >= 0xD800 && *utf16 <= 0xDFFF) {
@@ -303,7 +303,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline size_t utf16_measure(char32_t ch)
+    constexpr size_t utf16_measure(char32_t ch)
     {
         // Out-of-range code point always gets replaced
         if (ch < 0x10000 || ch > 0x10FFFF)
@@ -314,7 +314,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline conversion_error_t write_utf16(char16_t *&dest, char32_t ch)
+    constexpr conversion_error_t write_utf16(char16_t *&dest, char32_t ch)
     {
         if (ch < 0x10000) {
             *dest++ = static_cast<char16_t>(ch);
@@ -330,7 +330,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline size_t utf8_measure_from_utf16(const char16_t *utf16, size_t size)
+    constexpr size_t utf8_measure_from_utf16(const char16_t *utf16, size_t size)
     {
         if (!utf16)
             return 0;
@@ -344,7 +344,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline conversion_error_t utf8_convert_from_utf16(char *dest,
+    constexpr conversion_error_t utf8_convert_from_utf16(char *dest,
                     const char16_t *utf16, size_t size,
                     ST::utf_validation_t validation)
     {
@@ -370,7 +370,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline size_t utf8_measure_from_utf32(const char32_t *utf32, size_t size)
+    constexpr size_t utf8_measure_from_utf32(const char32_t *utf32, size_t size)
     {
         if (!utf32)
             return 0;
@@ -384,7 +384,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline conversion_error_t utf8_convert_from_utf32(char *dest,
+    constexpr conversion_error_t utf8_convert_from_utf32(char *dest,
                     const char32_t *utf32, size_t size,
                     ST::utf_validation_t validation)
     {
@@ -405,7 +405,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline size_t utf8_measure_from_latin_1(const char *astr, size_t size)
+    constexpr size_t utf8_measure_from_latin_1(const char *astr, size_t size)
     {
         if (!astr)
             return 0;
@@ -422,7 +422,7 @@ namespace _ST_PRIVATE
         return u8len;
     }
 
-    inline void utf8_convert_from_latin_1(char *dest, const char *astr, size_t size)
+    constexpr void utf8_convert_from_latin_1(char *dest, const char *astr, size_t size)
     {
         const char *sp = astr;
         const char *ep = sp + size;
@@ -475,7 +475,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline size_t utf16_measure_from_utf32(const char32_t *utf32, size_t size)
+    constexpr  size_t utf16_measure_from_utf32(const char32_t *utf32, size_t size)
     {
         if (!utf32)
             return 0;
@@ -489,7 +489,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline conversion_error_t utf16_convert_from_utf32(char16_t *dest,
+    constexpr conversion_error_t utf16_convert_from_utf32(char16_t *dest,
                     const char32_t *utf32, size_t size,
                     ST::utf_validation_t validation)
     {
@@ -547,7 +547,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline size_t utf32_measure_from_utf16(const char16_t *utf16, size_t size)
+    constexpr size_t utf32_measure_from_utf16(const char16_t *utf16, size_t size)
     {
         if (!utf16)
             return 0;
@@ -563,7 +563,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline conversion_error_t utf32_convert_from_utf16(char32_t *dest,
+    constexpr conversion_error_t utf32_convert_from_utf16(char32_t *dest,
                     const char16_t *utf16, size_t size,
                     ST::utf_validation_t validation)
     {
@@ -585,15 +585,15 @@ namespace _ST_PRIVATE
         return conversion_error_t::success;
     }
 
-    inline void utf16_convert_from_latin_1(char16_t *dest, const char *astr, size_t size)
+    constexpr void utf16_convert_from_latin_1(char16_t *dest, const char *astr, size_t size)
     {
         const char *sp = astr;
         const char *ep = sp + size;
         while (sp < ep)
             *dest++ = static_cast<unsigned char>(*sp++);
     }
 
-    inline void utf32_convert_from_latin_1(char32_t *dest, const char *astr, size_t size)
+    constexpr void utf32_convert_from_latin_1(char32_t *dest, const char *astr, size_t size)
     {
         const char *sp = astr;
         const char *ep = sp + size;
@@ -639,14 +639,14 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline size_t latin_1_measure_from_utf16(const char16_t *utf16, size_t size)
+    constexpr size_t latin_1_measure_from_utf16(const char16_t *utf16, size_t size)
     {
         // This always returns the same answer as UTF-32
         return utf32_measure_from_utf16(utf16, size);
     }
 
     ST_NODISCARD
-    inline conversion_error_t latin_1_convert_from_utf16(char *dest,
+    constexpr conversion_error_t latin_1_convert_from_utf16(char *dest,
                     const char16_t *utf16, size_t size,
                     ST::utf_validation_t validation,
                     bool substitute_out_of_range)
@@ -676,7 +676,7 @@ namespace _ST_PRIVATE
     }
 
     ST_NODISCARD
-    inline conversion_error_t latin_1_convert_from_utf32(char *dest,
+    constexpr conversion_error_t latin_1_convert_from_utf32(char *dest,
                     const char32_t *utf32, size_t size,
                     ST::utf_validation_t validation,
                     bool substitute_out_of_range)

Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ namespace _ST_PRIVATE`
`37`	`37`	`latin1_out_of_range,`
`38`	`38`	`};`
`39`	`39`
`40`		`- inline void raise_conversion_error(conversion_error_t err)`
	`40`	`+ constexpr void raise_conversion_error(conversion_error_t err)`
`41`	`41`	`{`
`42`	`42`	`switch (err) {`
`43`	`43`	`case conversion_error_t::success:`
`@@ -176,21 +176,21 @@ namespace _ST_PRIVATE`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`ST_NODISCARD`
`179`		`- inline char32_t error_char(conversion_error_t value)`
	`179`	`+ constexpr char32_t error_char(conversion_error_t value)`
`180`	`180`	`{`
`181`	`181`	`return static_cast<char32_t>(value) \| 0x400000u;`
`182`	`182`	`}`
`183`	`183`
`184`	`184`	`ST_NODISCARD`
`185`		`- inline conversion_error_t char_error(char32_t ch)`
	`185`	`+ constexpr conversion_error_t char_error(char32_t ch)`
`186`	`186`	`{`
`187`	`187`	`return (ch & 0x400000u) != 0`
`188`	`188`	`? static_cast<conversion_error_t>(ch & ~0x400000u)`
`189`	`189`	`: conversion_error_t::success;`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`ST_NODISCARD`
`193`		`- inline char32_t extract_utf8(const unsigned char &utf8, const unsigned char end)`
	`193`	`+ constexpr char32_t extract_utf8(const unsigned char &utf8, const unsigned char end)`
`194`	`194`	`{`
`195`	`195`	`char32_t bigch;`
`196`	`196`	`if (*utf8 < 0x80) {`
`@@ -230,7 +230,7 @@ namespace _ST_PRIVATE`
`230`	`230`	`}`
`231`	`231`
`232`	`232`	`ST_NODISCARD`
`233`		`- inline size_t utf8_measure(char32_t ch)`
	`233`	`+ constexpr size_t utf8_measure(char32_t ch)`
`234`	`234`	`{`
`235`	`235`	`if (ch < 0x80) {`
`236`	`236`	`return 1;`
`@@ -247,7 +247,7 @@ namespace _ST_PRIVATE`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`ST_NODISCARD`
`250`		`- inline conversion_error_t write_utf8(char *&dest, char32_t ch)`
	`250`	`+ constexpr conversion_error_t write_utf8(char *&dest, char32_t ch)`
`251`	`251`	`{`
`252`	`252`	`if (ch < 0x80) {`
`253`	`253`	`*dest++ = static_cast<char>(ch);`
`@@ -272,7 +272,7 @@ namespace _ST_PRIVATE`
`272`	`272`	`}`
`273`	`273`
`274`	`274`	`ST_NODISCARD`
`275`		`- inline char32_t extract_utf16(const char16_t &utf16, const char16_t end)`
	`275`	`+ constexpr char32_t extract_utf16(const char16_t &utf16, const char16_t end)`
`276`	`276`	`{`
`277`	`277`	`char32_t bigch;`
`278`	`278`	`if (utf16 >= 0xD800 && utf16 <= 0xDFFF) {`
`@@ -303,7 +303,7 @@ namespace _ST_PRIVATE`
`303`	`303`	`}`
`304`	`304`
`305`	`305`	`ST_NODISCARD`
`306`		`- inline size_t utf16_measure(char32_t ch)`
	`306`	`+ constexpr size_t utf16_measure(char32_t ch)`
`307`	`307`	`{`
`308`	`308`	`// Out-of-range code point always gets replaced`
`309`	`309`	`if (ch < 0x10000 \|\| ch > 0x10FFFF)`
`@@ -314,7 +314,7 @@ namespace _ST_PRIVATE`
`314`	`314`	`}`
`315`	`315`
`316`	`316`	`ST_NODISCARD`
`317`		`- inline conversion_error_t write_utf16(char16_t *&dest, char32_t ch)`
	`317`	`+ constexpr conversion_error_t write_utf16(char16_t *&dest, char32_t ch)`
`318`	`318`	`{`
`319`	`319`	`if (ch < 0x10000) {`
`320`	`320`	`*dest++ = static_cast<char16_t>(ch);`
`@@ -330,7 +330,7 @@ namespace _ST_PRIVATE`
`330`	`330`	`}`
`331`	`331`
`332`	`332`	`ST_NODISCARD`
`333`		`- inline size_t utf8_measure_from_utf16(const char16_t *utf16, size_t size)`
	`333`	`+ constexpr size_t utf8_measure_from_utf16(const char16_t *utf16, size_t size)`
`334`	`334`	`{`
`335`	`335`	`if (!utf16)`
`336`	`336`	`return 0;`
`@@ -344,7 +344,7 @@ namespace _ST_PRIVATE`
`344`	`344`	`}`
`345`	`345`
`346`	`346`	`ST_NODISCARD`
`347`		`- inline conversion_error_t utf8_convert_from_utf16(char *dest,`
	`347`	`+ constexpr conversion_error_t utf8_convert_from_utf16(char *dest,`
`348`	`348`	`const char16_t *utf16, size_t size,`
`349`	`349`	`ST::utf_validation_t validation)`
`350`	`350`	`{`
`@@ -370,7 +370,7 @@ namespace _ST_PRIVATE`
`370`	`370`	`}`
`371`	`371`
`372`	`372`	`ST_NODISCARD`
`373`		`- inline size_t utf8_measure_from_utf32(const char32_t *utf32, size_t size)`
	`373`	`+ constexpr size_t utf8_measure_from_utf32(const char32_t *utf32, size_t size)`
`374`	`374`	`{`
`375`	`375`	`if (!utf32)`
`376`	`376`	`return 0;`
`@@ -384,7 +384,7 @@ namespace _ST_PRIVATE`
`384`	`384`	`}`
`385`	`385`
`386`	`386`	`ST_NODISCARD`
`387`		`- inline conversion_error_t utf8_convert_from_utf32(char *dest,`
	`387`	`+ constexpr conversion_error_t utf8_convert_from_utf32(char *dest,`
`388`	`388`	`const char32_t *utf32, size_t size,`
`389`	`389`	`ST::utf_validation_t validation)`
`390`	`390`	`{`
`@@ -405,7 +405,7 @@ namespace _ST_PRIVATE`
`405`	`405`	`}`
`406`	`406`
`407`	`407`	`ST_NODISCARD`
`408`		`- inline size_t utf8_measure_from_latin_1(const char *astr, size_t size)`
	`408`	`+ constexpr size_t utf8_measure_from_latin_1(const char *astr, size_t size)`
`409`	`409`	`{`
`410`	`410`	`if (!astr)`
`411`	`411`	`return 0;`
`@@ -422,7 +422,7 @@ namespace _ST_PRIVATE`
`422`	`422`	`return u8len;`
`423`	`423`	`}`
`424`	`424`
`425`		`- inline void utf8_convert_from_latin_1(char dest, const char astr, size_t size)`
	`425`	`+ constexpr void utf8_convert_from_latin_1(char dest, const char astr, size_t size)`
`426`	`426`	`{`
`427`	`427`	`const char *sp = astr;`
`428`	`428`	`const char *ep = sp + size;`
`@@ -475,7 +475,7 @@ namespace _ST_PRIVATE`
`475`	`475`	`}`
`476`	`476`
`477`	`477`	`ST_NODISCARD`
`478`		`- inline size_t utf16_measure_from_utf32(const char32_t *utf32, size_t size)`
	`478`	`+ constexpr size_t utf16_measure_from_utf32(const char32_t *utf32, size_t size)`
`479`	`479`	`{`
`480`	`480`	`if (!utf32)`
`481`	`481`	`return 0;`
`@@ -489,7 +489,7 @@ namespace _ST_PRIVATE`
`489`	`489`	`}`
`490`	`490`
`491`	`491`	`ST_NODISCARD`
`492`		`- inline conversion_error_t utf16_convert_from_utf32(char16_t *dest,`
	`492`	`+ constexpr conversion_error_t utf16_convert_from_utf32(char16_t *dest,`
`493`	`493`	`const char32_t *utf32, size_t size,`
`494`	`494`	`ST::utf_validation_t validation)`
`495`	`495`	`{`
`@@ -547,7 +547,7 @@ namespace _ST_PRIVATE`
`547`	`547`	`}`
`548`	`548`
`549`	`549`	`ST_NODISCARD`
`550`		`- inline size_t utf32_measure_from_utf16(const char16_t *utf16, size_t size)`
	`550`	`+ constexpr size_t utf32_measure_from_utf16(const char16_t *utf16, size_t size)`
`551`	`551`	`{`
`552`	`552`	`if (!utf16)`
`553`	`553`	`return 0;`
`@@ -563,7 +563,7 @@ namespace _ST_PRIVATE`
`563`	`563`	`}`
`564`	`564`
`565`	`565`	`ST_NODISCARD`
`566`		`- inline conversion_error_t utf32_convert_from_utf16(char32_t *dest,`
	`566`	`+ constexpr conversion_error_t utf32_convert_from_utf16(char32_t *dest,`
`567`	`567`	`const char16_t *utf16, size_t size,`
`568`	`568`	`ST::utf_validation_t validation)`
`569`	`569`	`{`
`@@ -585,15 +585,15 @@ namespace _ST_PRIVATE`
`585`	`585`	`return conversion_error_t::success;`
`586`	`586`	`}`
`587`	`587`
`588`		`- inline void utf16_convert_from_latin_1(char16_t dest, const char astr, size_t size)`
	`588`	`+ constexpr void utf16_convert_from_latin_1(char16_t dest, const char astr, size_t size)`
`589`	`589`	`{`
`590`	`590`	`const char *sp = astr;`
`591`	`591`	`const char *ep = sp + size;`
`592`	`592`	`while (sp < ep)`
`593`	`593`	`dest++ = static_cast<unsigned char>(sp++);`
`594`	`594`	`}`
`595`	`595`
`596`		`- inline void utf32_convert_from_latin_1(char32_t dest, const char astr, size_t size)`
	`596`	`+ constexpr void utf32_convert_from_latin_1(char32_t dest, const char astr, size_t size)`
`597`	`597`	`{`
`598`	`598`	`const char *sp = astr;`
`599`	`599`	`const char *ep = sp + size;`
`@@ -639,14 +639,14 @@ namespace _ST_PRIVATE`
`639`	`639`	`}`
`640`	`640`
`641`	`641`	`ST_NODISCARD`
`642`		`- inline size_t latin_1_measure_from_utf16(const char16_t *utf16, size_t size)`
	`642`	`+ constexpr size_t latin_1_measure_from_utf16(const char16_t *utf16, size_t size)`
`643`	`643`	`{`
`644`	`644`	`// This always returns the same answer as UTF-32`
`645`	`645`	`return utf32_measure_from_utf16(utf16, size);`
`646`	`646`	`}`
`647`	`647`
`648`	`648`	`ST_NODISCARD`
`649`		`- inline conversion_error_t latin_1_convert_from_utf16(char *dest,`
	`649`	`+ constexpr conversion_error_t latin_1_convert_from_utf16(char *dest,`
`650`	`650`	`const char16_t *utf16, size_t size,`
`651`	`651`	`ST::utf_validation_t validation,`
`652`	`652`	`bool substitute_out_of_range)`
`@@ -676,7 +676,7 @@ namespace _ST_PRIVATE`
`676`	`676`	`}`
`677`	`677`
`678`	`678`	`ST_NODISCARD`
`679`		`- inline conversion_error_t latin_1_convert_from_utf32(char *dest,`
	`679`	`+ constexpr conversion_error_t latin_1_convert_from_utf32(char *dest,`
`680`	`680`	`const char32_t *utf32, size_t size,`
`681`	`681`	`ST::utf_validation_t validation,`
`682`	`682`	`bool substitute_out_of_range)`