SkString.cpp File Reference

#include "include/core/SkString.h"
#include "include/private/base/SkDebug.h"
#include "include/private/base/SkFloatingPoint.h"
#include "include/private/base/SkMalloc.h"
#include "include/private/base/SkTPin.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkSafeMath.h"
#include "src/base/SkUTF.h"
#include "src/base/SkUtils.h"
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <new>
#include <string_view>
#include <utility>

Go to the source code of this file.

Classes
struct	StringBuffer

Macros
#define	SizeOfRec()   (gEmptyRec.data() - (const char*)&gEmptyRec)

Functions
template<int SIZE>
static StringBuffer	apply_format_string (const char *format, va_list args, char(&stackBuffer)[SIZE], SkString *heapBuffer) SK_PRINTF_LIKE(1
template<int SIZE>
static StringBuffer static StringBuffer	apply_format_string (const char *format, va_list args, char(&stackBuffer)[SIZE], SkString *heapBuffer)
bool	SkStrEndsWith (const char string[], const char suffixStr[])
bool	SkStrEndsWith (const char string[], const char suffixChar)
int	SkStrStartsWithOneOf (const char string[], const char prefixes[])
char *	SkStrAppendU32 (char string[], uint32_t dec)
char *	SkStrAppendS32 (char string[], int32_t dec)
char *	SkStrAppendU64 (char string[], uint64_t dec, int minDigits)
char *	SkStrAppendS64 (char string[], int64_t dec, int minDigits)
char *	SkStrAppendScalar (char string[], SkScalar value)
static uint32_t	trim_size_t_to_u32 (size_t value)
static size_t	check_add32 (size_t base, size_t extra)
SkString	SkStringPrintf (const char *format,...)

Variables
static const size_t	kBufferSize = 1024

Macro Definition Documentation

SizeOfRec

#define SizeOfRec

(

)

(gEmptyRec.data() - (const char*)&gEmptyRec)

Definition at line 195 of file SkString.cpp.

Function Documentation

apply_format_string() [1/2]

template<int SIZE>

static StringBuffer static StringBuffer apply_format_string ( const char *  format, va_list  args, char(&)  stackBuffer[SIZE], SkString *  heapBuffer  )

static

Definition at line 39 of file SkString.cpp.

                                                              {
    // First, attempt to print directly to the stack buffer.
    va_list argsCopy;
    va_copy(argsCopy, args);
    int outLength = std::vsnprintf(stackBuffer, SIZE, format, args);
    if (outLength < 0) {
        SkDebugf("SkString: vsnprintf reported error.");
        va_end(argsCopy);
        return {stackBuffer, 0};
    }
    if (outLength < SIZE) {
        va_end(argsCopy);
        return {stackBuffer, outLength};
    }
 
    // Our text was too long to fit on the stack! However, we now know how much space we need to
    // format it. Format the string into our heap buffer. `set` automatically reserves an extra
    // byte at the end of the buffer for a null terminator, so we don't need to add one here.
    heapBuffer->set(nullptr, outLength);
    char* heapBufferDest = heapBuffer->data();
    SkDEBUGCODE(int checkLength =) std::vsnprintf(heapBufferDest, outLength + 1, format, argsCopy);
    SkASSERT(checkLength == outLength);
    va_end(argsCopy);
    return {heapBufferDest, outLength};
}

apply_format_string() [2/2]

template<int SIZE>

static StringBuffer apply_format_string ( const char *  format, va_list  args, char(&)  stackBuffer[SIZE], SkString *  heapBuffer  )

static

check_add32()

static size_t check_add32 ( size_t  base, size_t  extra  )

static

Definition at line 206 of file SkString.cpp.

                                                     {
    SkASSERT(base <= UINT32_MAX);
    if (sizeof(size_t) > sizeof(uint32_t)) {
        if (base + extra > UINT32_MAX) {
            extra = UINT32_MAX - base;
        }
    }
    return extra;
}

SkStrAppendS32()

char * SkStrAppendS32	(	char	string[],
		int32_t	dec
	)

Definition at line 120 of file SkString.cpp.

                                                 {
    uint32_t udec = dec;
    if (dec < 0) {
        *string++ = '-';
        udec = ~udec + 1;  // udec = -udec, but silences some warnings that are trying to be helpful
    }
    return SkStrAppendU32(string, udec);
}

SkStrAppendS64()

char * SkStrAppendS64	(	char	string[],
		int64_t	dec,
		int	minDigits
	)

Definition at line 155 of file SkString.cpp.

                                                                {
    uint64_t udec = dec;
    if (dec < 0) {
        *string++ = '-';
        udec = ~udec + 1;  // udec = -udec, but silences some warnings that are trying to be helpful
    }
    return SkStrAppendU64(string, udec, minDigits);
}

SkStrAppendScalar()

char * SkStrAppendScalar	(	char	buffer[],
		SkScalar	value
	)

Write the scalar in decimal format into buffer, and return a pointer to the next char after the last one written. Note: a terminating 0 is not written into buffer, which must be at least kSkStrAppendScalar_MaxSize. Thus if the caller wants to add a 0 at the end, buffer must be at least kSkStrAppendScalar_MaxSize + 1 bytes large.

Definition at line 164 of file SkString.cpp.

                                                       {
    // Handle infinity and NaN ourselves to ensure consistent cross-platform results.
    // (e.g.: `inf` versus `1.#INF00`, `nan` versus `-nan` for high-bit-set NaNs)
    if (SkIsNaN(value)) {
        strcpy(string, "nan");
        return string + 3;
    }
    if (!SkIsFinite(value)) {
        if (value > 0) {
            strcpy(string, "inf");
            return string + 3;
        } else {
            strcpy(string, "-inf");
            return string + 4;
        }
    }
 
    // since floats have at most 8 significant digits, we limit our %g to that.
    static const char gFormat[] = "%.8g";
    // make it 1 larger for the terminating 0
    char buffer[kSkStrAppendScalar_MaxSize + 1];
    int len = snprintf(buffer, sizeof(buffer), gFormat, value);
    memcpy(string, buffer, len);
    SkASSERT(len <= kSkStrAppendScalar_MaxSize);
    return string + len;
}

SkStrAppendU32()

char * SkStrAppendU32	(	char	string[],
		uint32_t	dec
	)

Definition at line 100 of file SkString.cpp.

                                                  {
    SkDEBUGCODE(char* start = string;)
 
    char    buffer[kSkStrAppendU32_MaxSize];
    char*   p = buffer + sizeof(buffer);
 
    do {
        *--p = SkToU8('0' + dec % 10);
        dec /= 10;
    } while (dec != 0);
 
    SkASSERT(p >= buffer);
    size_t cp_len = buffer + sizeof(buffer) - p;
    memcpy(string, p, cp_len);
    string += cp_len;
 
    SkASSERT(string - start <= kSkStrAppendU32_MaxSize);
    return string;
}

SkStrAppendU64()

char * SkStrAppendU64	(	char	string[],
		uint64_t	dec,
		int	minDigits
	)

Definition at line 129 of file SkString.cpp.

                                                                 {
    SkDEBUGCODE(char* start = string;)
 
    char    buffer[kSkStrAppendU64_MaxSize];
    char*   p = buffer + sizeof(buffer);
 
    do {
        *--p = SkToU8('0' + (int32_t) (dec % 10));
        dec /= 10;
        minDigits--;
    } while (dec != 0);
 
    while (minDigits > 0) {
        *--p = '0';
        minDigits--;
    }
 
    SkASSERT(p >= buffer);
    size_t cp_len = buffer + sizeof(buffer) - p;
    memcpy(string, p, cp_len);
    string += cp_len;
 
    SkASSERT(string - start <= kSkStrAppendU64_MaxSize);
    return string;
}

SkStrEndsWith() [1/2]

bool SkStrEndsWith	(	const char	string[],
		const char	suffixChar
	)

Definition at line 77 of file SkString.cpp.

                                                               {
    SkASSERT(string);
    size_t  strLen = strlen(string);
    if (0 == strLen) {
        return false;
    } else {
        return (suffixChar == string[strLen-1]);
    }
}

SkStrEndsWith() [2/2]

bool SkStrEndsWith	(	const char	string[],
		const char	suffixStr[]
	)

Definition at line 68 of file SkString.cpp.

                                                                {
    SkASSERT(string);
    SkASSERT(suffixStr);
    size_t  strLen = strlen(string);
    size_t  suffixLen = strlen(suffixStr);
    return  strLen >= suffixLen &&
            !strncmp(string + strLen - suffixLen, suffixStr, suffixLen);
}

SkStringPrintf()

SkString SkStringPrintf	(	const char *	format,
			...
	)

Definition at line 629 of file SkString.cpp.

                                                 {
    SkString formattedOutput;
    va_list args;
    va_start(args, format);
    formattedOutput.printVAList(format, args);
    va_end(args);
    return formattedOutput;
}

SkStrStartsWithOneOf()

int SkStrStartsWithOneOf	(	const char	string[],
		const char	prefixes[]
	)

Definition at line 87 of file SkString.cpp.

                                                                     {
    int index = 0;
    do {
        const char* limit = strchr(prefixes, '\0');
        if (!strncmp(string, prefixes, limit - prefixes)) {
            return index;
        }
        prefixes = limit + 1;
        index++;
    } while (prefixes[0]);
    return -1;
}

trim_size_t_to_u32()

static uint32_t trim_size_t_to_u32 ( size_t  value )

static

Definition at line 197 of file SkString.cpp.

                                                 {
    if (sizeof(size_t) > sizeof(uint32_t)) {
        if (value > UINT32_MAX) {
            value = UINT32_MAX;
        }
    }
    return (uint32_t)value;
}

Variable Documentation

kBufferSize

const size_t kBufferSize = 1024

static

Definition at line 27 of file SkString.cpp.