ascii.h File Reference

#include "port/simd.h"

Include dependency graph for ascii.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
void	ascii_safe_strlcpy (char *dest, const char *src, size_t destsiz)
static bool	is_valid_ascii (const unsigned char *s, int len)

Function Documentation

ascii_safe_strlcpy()

void ascii_safe_strlcpy ( char *  dest, const char *  src, size_t  destsiz  )

extern

Definition at line 174 of file ascii.c.

{
    if (destsiz == 0)           /* corner case: no room for trailing nul */
        return;
 
    while (--destsiz > 0)
    {
        /* use unsigned char here to avoid compiler warning */
        unsigned char ch = *src++;
 
        if (ch == '\0')
            break;
        /* Keep printable ASCII characters */
        if (32 <= ch && ch <= 127)
            *dest = ch;
        /* White-space is also OK */
        else if (ch == '\n' || ch == '\r' || ch == '\t')
            *dest = ch;
        /* Everything else is replaced with '?' */
        else
            *dest = '?';
        dest++;
    }
 
    *dest = '\0';
}

References fb().

Referenced by BackgroundWorkerStateChange(), and pgstat_get_crashed_backend_activity().

is_valid_ascii()

static bool is_valid_ascii ( const unsigned char *  s, int  len  )

inlinestatic

Definition at line 25 of file ascii.h.

{
    const unsigned char *const s_end = s + len;
    Vector8     chunk;
    Vector8     highbit_cum = vector8_broadcast(0);
#ifdef USE_NO_SIMD
    Vector8     zero_cum = vector8_broadcast(0x80);
#endif
 
    Assert(len % sizeof(chunk) == 0);
 
    while (s < s_end)
    {
        vector8_load(&chunk, s);
 
        /* Capture any zero bytes in this chunk. */
#ifdef USE_NO_SIMD
 
        /*
         * First, add 0x7f to each byte. This sets the high bit in each byte,
         * unless it was a zero. If any resulting high bits are zero, the
         * corresponding high bits in the zero accumulator will be cleared.
         *
         * If none of the bytes in the chunk had the high bit set, the max
         * value each byte can have after the addition is 0x7f + 0x7f = 0xfe,
         * and we don't need to worry about carrying over to the next byte. If
         * any input bytes did have the high bit set, it doesn't matter
         * because we check for those separately.
         */
        zero_cum &= (chunk + vector8_broadcast(0x7F));
#else
 
        /*
         * Set all bits in each lane of the highbit accumulator where input
         * bytes are zero.
         */
        highbit_cum = vector8_or(highbit_cum,
                                 vector8_eq(chunk, vector8_broadcast(0)));
#endif
 
        /* Capture all set bits in this chunk. */
        highbit_cum = vector8_or(highbit_cum, chunk);
 
        s += sizeof(chunk);
    }
 
    /* Check if any high bits in the high bit accumulator got set. */
    if (vector8_is_highbit_set(highbit_cum))
        return false;
 
#ifdef USE_NO_SIMD
    /* Check if any high bits in the zero accumulator got cleared. */
    if (zero_cum != vector8_broadcast(0x80))
        return false;
#endif
 
    return true;
}

References Assert, fb(), len, vector8_broadcast(), vector8_is_highbit_set(), vector8_load(), and vector8_or().

Referenced by pg_utf8_verifystr().