:: limine / common / lib / print.s2.c 5.8 KB raw

#include <stdarg.h>

#include <stddef.h>

#include <stdint.h>

#include <lib/print.h>

#include <lib/misc.h>

#include <lib/term.h>

#include <lib/libc.h>

#if defined (BIOS)

#include <lib/real.h>

#endif

#include <sys/cpu.h>

#include <drivers/serial.h>

​

#if defined (BIOS)

static void s2_print(const char *s, size_t len) {

    for (size_t i = 0; i < len; i++) {

        struct rm_regs r = {0};

        r.eax = 0x0e00 | s[i];

        rm_int(0x10, &r, &r);

    }

}

#endif

​

static const char *base_digits = "0123456789abcdef";

​

#define PRINT_BUF_MAX 4096

​

static void prn_char(char *print_buf, size_t *print_buf_i, char c) {

    if (c == '\n') {

        prn_char(print_buf, print_buf_i, '\r');

    }

​

    if (*print_buf_i < (PRINT_BUF_MAX - 1)) {

        print_buf[(*print_buf_i)++] = c;

    }

​

    print_buf[*print_buf_i] = 0;

}

​

static void prn_str(char *print_buf, size_t *print_buf_i, const char *string) {

    size_t i;

​

    for (i = 0; string[i]; i++) {

        prn_char(print_buf, print_buf_i, string[i]);

    }

}

​

static void prn_nstr(char *print_buf, size_t *print_buf_i, const char *string, size_t len) {

    size_t i;

​

    for (i = 0; i < len; i++) {

        prn_char(print_buf, print_buf_i, string[i]);

    }

}

​

static void prn_i(char *print_buf, size_t *print_buf_i, int64_t x) {

    int i;

    char buf[21] = {0};

​

    if (!x) {

        prn_char(print_buf, print_buf_i, '0');

        return;

    }

​

    int sign = x < 0;

    uint64_t ux = sign ? (uint64_t)0 - (uint64_t)x : (uint64_t)x;

​

    for (i = 19; ux; i--) {

        buf[i] = (ux % 10) + 0x30;

        ux = ux / 10;

    }

    if (sign)

        buf[i] = '-';

    else

        i++;

​

    prn_str(print_buf, print_buf_i, buf + i);

}

​

static void prn_ui(char *print_buf, size_t *print_buf_i, uint64_t x) {

    int i;

    char buf[21] = {0};

​

    if (!x) {

        prn_char(print_buf, print_buf_i, '0');

        return;

    }

​

    for (i = 19; x; i--) {

        buf[i] = (x % 10) + 0x30;

        x = x / 10;

    }

​

    i++;

    prn_str(print_buf, print_buf_i, buf + i);

}

​

static void prn_x(char *print_buf, size_t *print_buf_i, uint64_t x) {

    int i;

    char buf[17] = {0};

​

    if (!x) {

        prn_str(print_buf, print_buf_i, "0x0");

        return;

    }

​

    for (i = 15; x; i--) {

        buf[i] = base_digits[(x % 16)];

        x = x / 16;

    }

​

    i++;

    prn_str(print_buf, print_buf_i, "0x");

    prn_str(print_buf, print_buf_i, buf + i);

}

​

void print(const char *fmt, ...) {

    va_list args;

​

    va_start(args, fmt);

    vprint(fmt, args);

    va_end(args);

}

​

static char print_buf[PRINT_BUF_MAX];

​

void vprint(const char *fmt, va_list args) {

    size_t print_buf_i = 0;

​

    for (;;) {

        while (*fmt && *fmt != '%') {

            prn_char(print_buf, &print_buf_i, *fmt++);

        }

​

        if (!*fmt++)

            goto out;

​

        switch (*fmt++) {

            case 's': {

                char *str = (char *)va_arg(args, const char *);

                if (!str)

                    prn_str(print_buf, &print_buf_i, "(null)");

                else

                    prn_str(print_buf, &print_buf_i, str); }

                break;

            case 'S': {

                char *str = (char *)va_arg(args, const char *);

                size_t str_len = va_arg(args, size_t);

                if (!str)

                    prn_str(print_buf, &print_buf_i, "(null)");

                else

                    prn_nstr(print_buf, &print_buf_i, str, str_len); }

                break;

            case 'd':

                prn_i(print_buf, &print_buf_i, (int64_t)va_arg(args, int32_t));

                break;

            case 'u':

                prn_ui(print_buf, &print_buf_i, (uint64_t)va_arg(args, uint32_t));

                break;

            case 'x':

                prn_x(print_buf, &print_buf_i, (uint64_t)va_arg(args, uint32_t));

                break;

            case 'D':

                prn_i(print_buf, &print_buf_i, va_arg(args, int64_t));

                break;

            case 'U':

                prn_ui(print_buf, &print_buf_i, va_arg(args, uint64_t));

                break;

            case 'X':

                prn_x(print_buf, &print_buf_i, va_arg(args, uint64_t));

                break;

            case 'p':

                prn_x(print_buf, &print_buf_i, va_arg(args, uintptr_t));

                break;

            case 'c': {

                char c = (char)va_arg(args, int);

                prn_char(print_buf, &print_buf_i, c); }

                break;

            case '#': {

                bool printed = false;

                char *str = (char *)va_arg(args, const char *);

                for (int i = (int)strlen(str) - 1; i >= 0; i--) {

                    if (str[i] != '#') {

                        continue;

                    }

​

                    prn_nstr(print_buf, &print_buf_i, str, i);

                    printed = true;

                    break;

                }

​

                if (!printed) {

                    prn_str(print_buf, &print_buf_i, str);

                }

​

                break;

            }

            default:

                prn_char(print_buf, &print_buf_i, '?');

                break;

        }

    }

​

out:

    if (!quiet) {

#if defined (BIOS)

        if (stage3_loaded) {

#endif

            FOR_TERM(flanterm_write(TERM, print_buf, print_buf_i));

#if defined (BIOS)

        } else {

            s2_print(print_buf, print_buf_i);

        }

#endif

    }

​

    for (size_t i = 0; i < print_buf_i; i++) {

#if defined (__x86_64__) || defined (__i386__)

        if (E9_OUTPUT) {

            outb(0xe9, print_buf[i]);

        }

#endif

#if defined (BIOS)

        if (stage3_loaded && ((!quiet && serial) || COM_OUTPUT)) {

            if (!isprint(print_buf[i])) {

                switch (print_buf[i]) {

                    case '\r': case '\n': case '\e': break;

                    default: continue;

                }

            }

            serial_out(print_buf[i]);

        }

#endif

    }

}