stdlib.c File Reference

#include <uacpi/internal/stdlib.h>
#include <uacpi/internal/utilities.h>

Include dependency graph for stdlib.c:

Go to the source code of this file.

Classes
struct	fmt_buf_state
struct	fmt_spec

Macros
#define	REPR_BUFFER_SIZE   32

Enumerations
enum	parse_number_mode { PARSE_NUMBER_MODE_MAYBE , PARSE_NUMBER_MODE_MUST }

Functions
uacpi_size	uacpi_strlen (const uacpi_char *str)
uacpi_size	uacpi_strnlen (const uacpi_char *str, uacpi_size max)
uacpi_i32	uacpi_strcmp (const uacpi_char *lhs, const uacpi_char *rhs)
void	uacpi_memcpy_zerout (void *dst, const void *src, uacpi_size dst_size, uacpi_size src_size)
uacpi_u8	uacpi_bit_scan_forward (uacpi_u64 value)
uacpi_u8	uacpi_bit_scan_backward (uacpi_u64 value)
void *	uacpi_builtin_alloc_zeroed (uacpi_size size)
static void	write_one (struct fmt_buf_state *fb_state, uacpi_char c)
static void	write_many (struct fmt_buf_state *fb_state, const uacpi_char *string, uacpi_size count)
static uacpi_char	hex_char (uacpi_bool upper, uacpi_u64 value)
static void	write_padding (struct fmt_buf_state *fb_state, struct fmt_spec *fm, uacpi_size repr_size)
static void	write_integer (struct fmt_buf_state *fb_state, struct fmt_spec *fm, uacpi_u64 value)
static uacpi_bool	string_has_at_least (const uacpi_char *string, uacpi_size characters)
static uacpi_bool	consume_digits (const uacpi_char **string, uacpi_size *out_size)
static uacpi_bool	parse_number (const uacpi_char **fmt, enum parse_number_mode mode, uacpi_u64 *out_value)
static uacpi_bool	consume (const uacpi_char **string, const uacpi_char *token)
static uacpi_bool	is_one_of (uacpi_char c, const uacpi_char *list)
static uacpi_bool	consume_one_of (const uacpi_char **string, const uacpi_char *list, uacpi_char *consumed_char)
static uacpi_u32	base_from_specifier (uacpi_char specifier)
static uacpi_bool	is_uppercase_specifier (uacpi_char specifier)
static const uacpi_char *	find_next_conversion (const uacpi_char *fmt, uacpi_size *offset)
uacpi_i32	uacpi_vsnprintf (uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt, uacpi_va_list vlist)
uacpi_i32	uacpi_snprintf (uacpi_char *buffer, uacpi_size capacity, const uacpi_char *fmt,...)
void	uacpi_log (uacpi_log_level lvl, const uacpi_char *str,...)

Macro Definition Documentation

REPR_BUFFER_SIZE

#define REPR_BUFFER_SIZE   32

Definition at line 297 of file stdlib.c.

Enumeration Type Documentation

parse_number_mode

enum parse_number_mode

Enumerator
PARSE_NUMBER_MODE_MAYBE
PARSE_NUMBER_MODE_MUST

Definition at line 399 of file stdlib.c.

                       {
    PARSE_NUMBER_MODE_MAYBE,
    PARSE_NUMBER_MODE_MUST,
};

Function Documentation

base_from_specifier()

static uacpi_u32 base_from_specifier ( uacpi_char  specifier )

static

Definition at line 463 of file stdlib.c.

{
    switch (specifier)
    {
        case 'x':
        case 'X':
            return 16;
        case 'o':
            return 8;
        default:
            return 10;
    }
}

Referenced by uacpi_vsnprintf().

consume()

static uacpi_bool consume ( const uacpi_char **  string, const uacpi_char *  token  )

static

Definition at line 419 of file stdlib.c.

{
    uacpi_size token_size;
 
    token_size = uacpi_strlen(token);
 
    if (!string_has_at_least(*string, token_size))
        return UACPI_FALSE;
 
    if (!uacpi_memcmp(*string, token, token_size)) {
        *string += token_size;
        return UACPI_TRUE;
    }
 
    return UACPI_FALSE;
}

Referenced by uacpi_vsnprintf().

consume_digits()

static uacpi_bool consume_digits ( const uacpi_char **  string, uacpi_size *  out_size  )

static

Definition at line 377 of file stdlib.c.

{
    uacpi_size size = 0;
 
    for (;;) {
        char c = **string;
        if (c < '0' || c > '9')
            break;
 
        size++;
        *string += 1;
    }
 
    if (size == 0)
        return UACPI_FALSE;
 
    *out_size = size;
    return UACPI_TRUE;
}

Referenced by parse_number().

consume_one_of()

static uacpi_bool consume_one_of ( const uacpi_char **  string, const uacpi_char *  list, uacpi_char *  consumed_char  )

static

Definition at line 446 of file stdlib.c.

{
    uacpi_char c = **string;
    if (!c)
        return UACPI_FALSE;
 
    if (is_one_of(c, list)) {
        *consumed_char = c;
        *string += 1;
        return UACPI_TRUE;
    }
 
    return UACPI_FALSE;
}

Referenced by uacpi_vsnprintf().

find_next_conversion()

static const uacpi_char * find_next_conversion ( const uacpi_char *  fmt, uacpi_size *  offset  )

static

Definition at line 482 of file stdlib.c.

{
    *offset = 0;
 
    while (*fmt) {
        if (*fmt == '%')
            return fmt;
 
        fmt++;
        *offset += 1;
    }
 
    return UACPI_NULL;
}

Referenced by uacpi_vsnprintf().

hex_char()

static uacpi_char hex_char ( uacpi_bool  upper, uacpi_u64  value  )

static

Definition at line 274 of file stdlib.c.

{
    static const uacpi_char upper_hex[] = "0123456789ABCDEF";
    static const uacpi_char lower_hex[] = "0123456789abcdef";
 
    return (upper ? upper_hex : lower_hex)[value];
}

Referenced by write_integer().

is_one_of()

static uacpi_bool is_one_of ( uacpi_char  c, const uacpi_char *  list  )

static

Definition at line 436 of file stdlib.c.

{
    for (; *list; list++) {
        if (c == *list)
            return UACPI_TRUE;
    }
 
    return UACPI_FALSE;
}

Referenced by consume_one_of(), and uacpi_namespace_node_next_typed_unlocked().

is_uppercase_specifier()

static uacpi_bool is_uppercase_specifier ( uacpi_char  specifier )

static

Definition at line 477 of file stdlib.c.

{
    return specifier == 'X';
}

Referenced by uacpi_vsnprintf().

parse_number()

static uacpi_bool parse_number ( const uacpi_char **  fmt, enum parse_number_mode  mode, uacpi_u64 *  out_value  )

static

Definition at line 404 of file stdlib.c.

{
    uacpi_status ret;
    uacpi_size num_digits;
    const uacpi_char *digits = *fmt;
 
    if (!consume_digits(fmt, &num_digits))
        return mode != PARSE_NUMBER_MODE_MUST;
 
    ret = uacpi_string_to_integer(digits, num_digits, UACPI_BASE_DEC, out_value);
    return ret == UACPI_STATUS_OK;
}

Referenced by uacpi_vsnprintf().

string_has_at_least()

static uacpi_bool string_has_at_least ( const uacpi_char *  string, uacpi_size  characters  )

static

Definition at line 363 of file stdlib.c.

{
    while (*string) {
        if (--characters == 0)
            return UACPI_TRUE;
 
        string++;
    }
 
    return UACPI_FALSE;
}

Referenced by consume().

uacpi_bit_scan_backward()

uacpi_u8 uacpi_bit_scan_backward

(

uacpi_u64

value

)

Definition at line 166 of file stdlib.c.

{
#if defined(_MSC_VER) && !defined(__clang__)
    unsigned char ret;
    unsigned long index;
 
#ifdef _WIN64
    ret = _BitScanReverse64(&index, value);
    if (ret == 0)
        return 0;
 
    return (uacpi_u8)index + 1;
#else
    ret = _BitScanReverse(&index, value >> 32);
    if (ret == 0) {
        ret = _BitScanReverse(&index, value);
        if (ret == 0)
            return 0;
 
        return (uacpi_u8)index + 1;
    }
 
    return (uacpi_u8)index + 33;
#endif
 
#elif defined(__WATCOMC__)
    // TODO: Use compiler intrinsics or inline ASM here
    uacpi_u8 index;
    uacpi_u64 mask = (1ull << 63);
 
    for (index = 64; index > 0; index--, mask >>= 1) {
        if (value & mask) {
            return index;
        }
    }
 
    return 0;
#else
    if (value == 0)
        return 0;
 
    return 64 - __builtin_clzll(value);
#endif
}

Referenced by gas_get_access_bit_width(), and handle_unary_math().

uacpi_bit_scan_forward()

uacpi_u8 uacpi_bit_scan_forward

(

uacpi_u64

value

)

Definition at line 124 of file stdlib.c.

{
#if defined(_MSC_VER) && !defined(__clang__)
    unsigned char ret;
    unsigned long index;
 
#ifdef _WIN64
    ret = _BitScanForward64(&index, value);
    if (ret == 0)
        return 0;
 
    return (uacpi_u8)index + 1;
#else
    ret = _BitScanForward(&index, value);
    if (ret == 0) {
        ret = _BitScanForward(&index, value >> 32);
        if (ret == 0)
            return 0;
 
        return (uacpi_u8)index + 33;
    }
 
    return (uacpi_u8)index + 1;
#endif
 
#elif defined(__WATCOMC__)
    // TODO: Use compiler intrinsics or inline ASM here
    uacpi_u8 index;
    uacpi_u64 mask = 1;
 
    for (index = 1; index <= 64; index++, mask <<= 1) {
        if (value & mask) {
            return index;
        }
    }
 
    return 0;
#else
    return __builtin_ffsll(value);
#endif
}

Referenced by handle_unary_math().

uacpi_builtin_alloc_zeroed()

void * uacpi_builtin_alloc_zeroed

(

uacpi_size

size

)

Definition at line 212 of file stdlib.c.

{
    void *ptr;
 
    ptr = uacpi_kernel_alloc(size);
    if (uacpi_unlikely(ptr == UACPI_NULL))
        return ptr;
 
    uacpi_memzero(ptr, size);
    return ptr;
}

uacpi_log()

void uacpi_log	(	uacpi_log_level	lvl,
		const uacpi_char *	str,
			...
	)

Definition at line 706 of file stdlib.c.

{
    uacpi_char buf[UACPI_PLAIN_LOG_BUFFER_SIZE];
    int ret;
 
    uacpi_va_list vlist;
    uacpi_va_start(vlist, str);
 
    ret = uacpi_vsnprintf(buf, sizeof(buf), str, vlist);
    if (uacpi_unlikely(ret < 0))
        goto out;
 
    uacpi_kernel_log(lvl, buf);
 
out:
    uacpi_va_end(vlist);
}

uacpi_memcpy_zerout()

void uacpi_memcpy_zerout	(	void *	dst,
		const void *	src,
		uacpi_size	dst_size,
		uacpi_size	src_size
	)

Definition at line 112 of file stdlib.c.

{
    uacpi_size bytes_to_copy = UACPI_MIN(src_size, dst_size);
 
    if (bytes_to_copy)
        uacpi_memcpy(dst, src, bytes_to_copy);
 
    if (dst_size > bytes_to_copy)
        uacpi_memzero((uacpi_u8 *)dst + bytes_to_copy, dst_size - bytes_to_copy);
}

Referenced by buffer_alloc_and_store(), build_table_id(), do_aml_resource_to_native(), do_native_resource_to_aml(), exec_op(), handle_buffer(), handle_deref_of(), handle_special_field(), object_assign_with_implicit_cast(), object_to_integer(), uacpi_dispatch_opregion_io(), uacpi_read_field_unit(), uacpi_write_buffer_field(), and write_buffer_index().

uacpi_snprintf()

uacpi_i32 uacpi_snprintf	(	uacpi_char *	buffer,
		uacpi_size	capacity,
		const uacpi_char *	fmt,
			...
	)

Definition at line 690 of file stdlib.c.

{
    uacpi_va_list vlist;
    uacpi_i32 ret;
 
    uacpi_va_start(vlist, fmt);
    ret = uacpi_vsnprintf(buffer, capacity, fmt, vlist);
    uacpi_va_end(vlist);
 
    return ret;
}

Referenced by buffer_to_string(), handle_concatenate(), integer_to_string(), uacpi_eval_cls(), and uacpi_eval_uid().

uacpi_strcmp()

uacpi_i32 uacpi_strcmp	(	const uacpi_char *	lhs,
		const uacpi_char *	rhs
	)

Definition at line 96 of file stdlib.c.

{
    uacpi_size i = 0;
    typedef const uacpi_u8 *cucp;
 
    while (lhs[i] && rhs[i]) {
        if (lhs[i] != rhs[i])
            return *(cucp)&lhs[i] - *(cucp)&rhs[i];
 
        i++;
    }
 
    return *(cucp)&lhs[i] - *(cucp)&rhs[i];
}

Referenced by find_interface_unlocked(), matches_any(), and uacpi_uninstall_interface().

uacpi_strlen()

uacpi_size uacpi_strlen

(

const uacpi_char *

str

)

Definition at line 72 of file stdlib.c.

{
    const uacpi_char *str1;
 
    for (str1 = str; *str1; str1++);
 
    return str1 - str;
}

Referenced by consume(), uacpi_free_dynamic_string(), uacpi_install_interface(), uacpi_namespace_node_resolve(), and uacpi_object_create_cstring().

uacpi_strnlen()

uacpi_size uacpi_strnlen	(	const uacpi_char *	str,
		uacpi_size	max
	)

Definition at line 85 of file stdlib.c.

{
    const uacpi_char *str1;
 
    for (str1 = str; max-- && *str1; str1++);
 
    return str1 - str;
}

Referenced by handle_string(), and handle_to_string().

uacpi_vsnprintf()

uacpi_i32 uacpi_vsnprintf	(	uacpi_char *	buffer,
		uacpi_size	capacity,
		const uacpi_char *	fmt,
		uacpi_va_list	vlist
	)

Definition at line 499 of file stdlib.c.

{
    struct fmt_buf_state fb_state = { 0 };
    uacpi_u64 value;
    const uacpi_char *next_conversion;
    uacpi_size next_offset;
    uacpi_char flag;
 
    fb_state.buffer = buffer;
    fb_state.capacity = capacity;
    fb_state.bytes_written = 0;
 
    while (*fmt) {
        struct fmt_spec fm = {
            .pad_char = ' ',
            .base = 10,
        };
        next_conversion = find_next_conversion(fmt, &next_offset);
 
        if (next_offset)
            write_many(&fb_state, fmt, next_offset);
 
        if (!next_conversion)
            break;
 
        fmt = next_conversion;
        if (consume(&fmt, "%%")) {
            write_one(&fb_state, '%');
            continue;
        }
 
        // consume %
        fmt++;
 
        while (consume_one_of(&fmt, "+- 0#", &flag)) {
            switch (flag) {
            case '+':
            case ' ':
                fm.prepend = UACPI_TRUE;
                fm.prepend_char = flag;
                continue;
            case '-':
                fm.left_justify = UACPI_TRUE;
                continue;
            case '0':
                fm.pad_char = '0';
                continue;
            case '#':
                fm.alternate_form = UACPI_TRUE;
                continue;
            default:
                return -1;
            }
        }
 
        if (consume(&fmt, "*")) {
            fm.min_width = uacpi_va_arg(vlist, int);
        } else if (!parse_number(&fmt, PARSE_NUMBER_MODE_MAYBE, &fm.min_width)) {
            return -1;
        }
 
        if (consume(&fmt, ".")) {
            fm.has_precision = UACPI_TRUE;
 
            if (consume(&fmt, "*")) {
                fm.precision = uacpi_va_arg(vlist, int);
            } else {
                if (!parse_number(&fmt, PARSE_NUMBER_MODE_MUST, &fm.precision))
                    return -1;
            }
        }
 
        flag = 0;
 
        if (consume(&fmt, "c")) {
            uacpi_char c = uacpi_va_arg(vlist, int);
            write_one(&fb_state, c);
            continue;
        }
 
        if (consume(&fmt, "s")) {
            const uacpi_char *string = uacpi_va_arg(vlist, uacpi_char*);
            uacpi_size len = 0;
 
            if (uacpi_unlikely(string == UACPI_NULL))
                string = "<null>";
 
            while ((!fm.has_precision || len < fm.precision) && string[len])
                len++;
 
            if (fm.left_justify) {
                write_many(&fb_state, string, len);
                write_padding(&fb_state, &fm, len);
            } else {
                write_padding(&fb_state, &fm, len);
                write_many(&fb_state, string, len);
            }
            continue;
        }
 
        if (consume(&fmt, "p")) {
            value = (uacpi_uintptr)uacpi_va_arg(vlist, void*);
            fm.base = 16;
            fm.min_width = UACPI_POINTER_SIZE * 2;
            fm.pad_char = '0';
            goto write_int;
        }
 
        if (consume(&fmt, "hh")) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = (uacpi_u64)uacpi_va_arg(vlist, int);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = (unsigned char)uacpi_va_arg(vlist, int);
            } else {
                return -1;
            }
            goto write_int;
        }
 
        if (consume(&fmt, "h")) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = (signed short)uacpi_va_arg(vlist, int);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = (unsigned short)uacpi_va_arg(vlist, int);
            } else {
                return -1;
            }
            goto write_int;
        }
 
        if (consume(&fmt, "ll") ||
            (sizeof(uacpi_size) == sizeof(long long) && consume(&fmt, "z"))) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = uacpi_va_arg(vlist, long long);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = uacpi_va_arg(vlist, unsigned long long);
            } else {
                return -1;
            }
            goto write_int;
        }
 
        if (consume(&fmt, "l") ||
            (sizeof(uacpi_size) == sizeof(long) && consume(&fmt, "z"))) {
            if (consume(&fmt, "d") || consume(&fmt, "i")) {
                value = uacpi_va_arg(vlist, long);
                fm.is_signed = UACPI_TRUE;
            } else if (consume_one_of(&fmt, "oxXu", &flag)) {
                value = uacpi_va_arg(vlist, unsigned long);
            } else {
                return -1;
            }
            goto write_int;
        }
 
        if (consume(&fmt, "d") || consume(&fmt, "i")) {
            value = uacpi_va_arg(vlist, uacpi_i32);
            fm.is_signed = UACPI_TRUE;
        } else if (consume_one_of(&fmt, "oxXu", &flag)) {
            value = uacpi_va_arg(vlist, uacpi_u32);
        } else {
            return -1;
        }
 
    write_int:
        if (flag != 0) {
            fm.base = base_from_specifier(flag);
            fm.uppercase = is_uppercase_specifier(flag);
        }
 
        write_integer(&fb_state, &fm, value);
    }
 
    if (fb_state.capacity) {
        uacpi_size last_char;
 
        last_char = UACPI_MIN(fb_state.bytes_written, fb_state.capacity - 1);
        fb_state.buffer[last_char] = '\0';
    }
 
    return fb_state.bytes_written;
}

Referenced by uacpi_log(), and uacpi_snprintf().

write_integer()

static void write_integer ( struct fmt_buf_state *  fb_state, struct fmt_spec *  fm, uacpi_u64  value  )

static

Definition at line 299 of file stdlib.c.

{
    uacpi_char repr_buffer[REPR_BUFFER_SIZE];
    uacpi_size index = REPR_BUFFER_SIZE;
    uacpi_u64 remainder;
    uacpi_char repr;
    uacpi_bool negative = UACPI_FALSE;
    uacpi_size repr_size;
 
    if (fm->is_signed) {
        uacpi_i64 as_ll = value;
 
        if (as_ll < 0) {
            value = -as_ll;
            negative = UACPI_TRUE;
        }
    }
 
    if (fm->prepend || negative)
        write_one(fb_state, negative ? '-' : fm->prepend_char);
 
    while (value) {
        remainder = value % fm->base;
        value /= fm->base;
 
        if (fm->base == 16) {
            repr = hex_char(fm->uppercase, remainder);
        } else if (fm->base == 8 || fm->base == 10) {
            repr = remainder + '0';
        } else {
            repr = '?';
        }
 
        repr_buffer[--index] = repr;
    }
    repr_size = REPR_BUFFER_SIZE - index;
 
    if (repr_size == 0) {
        repr_buffer[--index] = '0';
        repr_size = 1;
    }
 
    if (fm->alternate_form) {
        if (fm->base == 16) {
            repr_buffer[--index] = fm->uppercase ? 'X' : 'x';
            repr_buffer[--index] = '0';
            repr_size += 2;
        } else if (fm->base == 8) {
            repr_buffer[--index] = '0';
            repr_size += 1;
        }
    }
 
    if (fm->left_justify) {
        write_many(fb_state, &repr_buffer[index], repr_size);
        write_padding(fb_state, fm, repr_size);
    } else {
        write_padding(fb_state, fm, repr_size);
        write_many(fb_state, &repr_buffer[index], repr_size);
    }
}

Referenced by uacpi_vsnprintf().

write_many()

static void write_many ( struct fmt_buf_state *  fb_state, const uacpi_char *  string, uacpi_size  count  )

static

Definition at line 256 of file stdlib.c.

{
    if (fb_state->bytes_written < fb_state->capacity) {
        uacpi_size count_to_write;
 
        count_to_write = UACPI_MIN(
            count, fb_state->capacity - fb_state->bytes_written
        );
        uacpi_memcpy(
            &fb_state->buffer[fb_state->bytes_written], string, count_to_write
        );
    }
 
    fb_state->bytes_written += count;
}

Referenced by uacpi_vsnprintf(), and write_integer().

write_one()

static void write_one ( struct fmt_buf_state *  fb_state, uacpi_char  c  )

static

Definition at line 248 of file stdlib.c.

{
    if (fb_state->bytes_written < fb_state->capacity)
        fb_state->buffer[fb_state->bytes_written] = c;
 
    fb_state->bytes_written++;
}

Referenced by uacpi_vsnprintf(), write_integer(), and write_padding().

write_padding()

static void write_padding ( struct fmt_buf_state *  fb_state, struct fmt_spec *  fm, uacpi_size  repr_size  )

static

Definition at line 282 of file stdlib.c.

{
    uacpi_u64 mw = fm->min_width;
 
    if (mw <= repr_size)
        return;
 
    mw -= repr_size;
 
    while (mw--)
        write_one(fb_state, fm->left_justify ? ' ' : fm->pad_char);
}

Referenced by uacpi_vsnprintf(), and write_integer().