Line data    Source code

       1             : /* File: utf8stringbuf.c; Copyright and License: see below */
       2             : 
       3             : #include <inttypes.h>
       4             : #include "utf8stringbuf/utf8stringbuf.h"
       5             : 
       6             : /* utf8stringbuf_private_empty_buf is constantly 0, but may be overwritten by a 0 - therefore stored in a read-writeable memory page */
       7             : char utf8stringbuf_private_empty_buf[1] = "";
       8             : 
       9             : const char *utf8stringbuf_private_format_signed_64_bit_int = "%" PRIi64;
      10             : 
      11             : const char *utf8stringbuf_private_format_64_bit_hex = "%" PRIx64;
      12             : 
      13             : /*!
      14             :  *  \fn utf8stringbuf_private_write_char( char *destination, unsigned int max_size, const uint32_t source )
      15             :  *  \private
      16             :  */
      17             : /* function to write a code point as utf8, returns the number of bytes written and an error code */
      18             : static inline utf8error_t utf8stringbuf_private_write_char( char *destination, unsigned int max_size, const uint32_t source, int *out_len );
      19             : 
      20             : /* utf8 sequences longer or equal 2 bytes start with a byte with 2 highest bits set: 0xc0 */
      21             : /* utf8 sequences longer or equal 3 bytes start with a byte with 3 highest bits set: 0xe0 */
      22             : /* utf8 sequences           equal 4 bytes start with a byte with 4 highest bits set: 0xf0 */
      23             : static const unsigned char utf8stringbuf_private_pattern_to_detect_half_utf8_sequences[5] = { 0, 0, 0xc0, 0xe0, 0xf0 };
      24             : 
      25             : /* Note: There is some magic in the design of utf8 which makes the implementation of this function quite short */
      26          85 : unsigned int utf8_string_buf_private_make_null_termination( utf8stringbuf_t *this_ ) {
      27             :     unsigned int truncatedLength;
      28          85 :     int clearAtEnd = 1;
      29             : 
      30         309 :     for ( int searchBackwards = 2; searchBackwards <= 4; searchBackwards ++ ) {
      31         237 :         if ( searchBackwards > (*this_).size ) {
      32           4 :             break;
      33             :         }
      34         233 :         const char pattern = utf8stringbuf_private_pattern_to_detect_half_utf8_sequences[searchBackwards];
      35         233 :         if ( ( (*this_).buf[(*this_).size-searchBackwards] & pattern ) == pattern ) {
      36           9 :             clearAtEnd = searchBackwards;
      37           9 :             break;
      38             :         }
      39             :     }
      40             : 
      41          85 :     truncatedLength = (*this_).size - clearAtEnd;
      42             :     /* (*this_).buf[truncatedLength] = '\0'; */ /* Note: some functions like splitIn2 require complete zeroed trailings */
      43          85 :     memset( &((*this_).buf[truncatedLength]), '\0', clearAtEnd );
      44          85 :     return truncatedLength;
      45             : }
      46             : 
      47          14 : utf8error_t utf8stringbuf_append_char( utf8stringbuf_t *this_, const uint32_t appendix ) {
      48             :     utf8error_t result;
      49          14 :     const unsigned int start = utf8stringbuf_get_length( this_ );
      50             :     int appendLen;
      51          14 :     result = utf8stringbuf_private_write_char( &((*this_).buf[start]), (*this_).size - start - 1, appendix, &appendLen );
      52          14 :     if ( result == UTF8ERROR_SUCCESS ) {
      53          11 :         (*this_).buf[start+appendLen] = '\0';
      54             :     }
      55          14 :     return result;
      56             : }
      57             : 
      58           5 : utf8error_t utf8stringbuf_append_wstr( utf8stringbuf_t *this_, const wchar_t *appendix ) {
      59           5 :     utf8error_t result = UTF8ERROR_NULL_PARAM;
      60           5 :     if ( appendix != NULL ) {
      61           4 :         unsigned int start = utf8stringbuf_get_length( this_ );
      62           4 :         result = UTF8ERROR_SUCCESS;
      63           9 :         for( ; appendix[0]!=L'\0'; appendix = &(appendix[1]) ) {
      64             :             int appendLen;
      65           7 :             result |= utf8stringbuf_private_write_char( &((*this_).buf[start]), (*this_).size - start - 1, appendix[0], &appendLen );
      66           7 :             if ( result != UTF8ERROR_SUCCESS ) {
      67           2 :                 if ( ( result & UTF8ERROR_TRUNCATED ) != 0 ) {
      68           2 :                     break;
      69             :                 }
      70             :             }
      71           5 :             start = start + appendLen;
      72             :         }
      73           4 :         (*this_).buf[start] = '\0';
      74             :     }
      75           5 :     return result;
      76             : }
      77             : 
      78          21 : static inline utf8error_t utf8stringbuf_private_write_char( char *destination, unsigned int max_size, const uint32_t source, int *out_len ) {
      79          21 :     *out_len = 0;
      80          21 :     utf8error_t result = UTF8ERROR_TRUNCATED;
      81          21 :     if ( source <= 0x7ff ) {
      82          12 :         if ( source <= 0x7f ) {
      83             :             /* 1 byte character */
      84             :             /* check if there is enough space for the character */
      85          10 :             if ( max_size >= 1 ) {
      86           8 :                 destination[0] = source;
      87           8 :                 *out_len = 1;
      88           8 :                 result = UTF8ERROR_SUCCESS;
      89             :             }
      90             :         }
      91             :         else {
      92             :             /* 2 byte character */
      93           2 :             if ( max_size >= 2 ) {
      94           2 :                 destination[0] = 0xc0 | ( source >> 6 );
      95           2 :                 destination[1] = 0x80 | ( source & 0x3f );
      96           2 :                 *out_len = 2;
      97           2 :                 result = UTF8ERROR_SUCCESS;
      98             :             }
      99             :         }
     100             :     }
     101             :     else {
     102           9 :         if ( source <= 0x10ffff ) {
     103           8 :             if ( source <= 0xffff ) {
     104             :                 /* 3 byte character */
     105           6 :                 if ( max_size >= 3 ) {
     106           4 :                     destination[0] = 0xe0 | ( source >> 12 );
     107           4 :                     destination[1] = 0x80 | (( source >> 6 ) & 0x3f );
     108           4 :                     destination[2] = 0x80 | ( source & 0x3f );
     109           4 :                     *out_len = 3;
     110           4 :                     result = UTF8ERROR_SUCCESS;
     111             :                 }
     112             :             }
     113             :             else {
     114             :                 /* 4 byte character */
     115           2 :                 if ( max_size >= 4 ) {
     116           2 :                     destination[0] = 0xf0 | ( source >> 18 );
     117           2 :                     destination[1] = 0x80 | (( source >> 12 ) & 0x3f );
     118           2 :                     destination[2] = 0x80 | (( source >> 6 ) & 0x3f );
     119           2 :                     destination[3] = 0x80 | ( source & 0x3f );
     120           2 :                     *out_len = 4;
     121           2 :                     result = UTF8ERROR_SUCCESS;
     122             :                 }
     123             :             }
     124             :         }
     125             :         else {
     126             :             /* note: utf8 can not encode more than 21 bits per character, and even there only 0-0x10ffff is allowed. */
     127           1 :             result = UTF8ERROR_NOT_A_CODEPOINT;
     128             :         }
     129             :     }
     130          21 :     return result;
     131             : }
     132             : 
     133             : 
     134             : /*
     135             :  * Copyright 2012-2025 Andreas Warnke
     136             :  *
     137             :  * Licensed under the Apache License, Version 2.0 (the "License");
     138             :  * you may not use this file except in compliance with the License.
     139             :  * You may obtain a copy of the License at
     140             :  *
     141             :  *    http://www.apache.org/licenses/LICENSE-2.0
     142             :  *
     143             :  * Unless required by applicable law or agreed to in writing, software
     144             :  * distributed under the License is distributed on an "AS IS" BASIS,
     145             :  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     146             :  * See the License for the specific language governing permissions and
     147             :  * limitations under the License.
     148             :  */