debug.c

Go to the documentation of this file.

#include <sys/types.h>
#include <stdio.h>
#include <stddef.h>
#include <stdarg.h>
#include <debug.h>

#define VIDEORAM 0xb8000
#define COLS 80
#define ROWS 25
#define MAXCOL 2000
#define TABSIZE 7
#define BGCOLOR 0x70

/* only for x86 and debugging */
static inline int hex_to_rstr(unsigned d, char *out)
{
        const char *hex_table = "0123456789abcdef";
        int ret;

        ret = 0;
        while (d / 16) {
                out[ret++] = hex_table[(d % 16)];
                d /= 16;
        }

        out[ret++] = hex_table[(d % 16)];
        return ret;
}

static inline int unsigned_to_rstr(unsigned d, char *out)
{
        int ret;

        ret = 0;
        while (d / 10) {
                out[ret++] = (d % 10) + '0';
                d /= 10;
        }

        out[ret++] = (d % 10) + '0';
        return ret;
}

static inline int signed_to_rstr(int d, char *out)
{
        int ret;
        
        ret = 0;
        while (d / 10) {
                out[ret++] = ((d % 10) * (d < 0 ? -1 : 1)) + '0';
                d /= 10;
        }

        out[ret++] = ((d % 10) * (d < 0 ? -1 : 1)) + '0';

        if (d < 0) {
                out[ret++] = '-';
        }
        return ret;
}

static inline int dbg_putc(char ch, off_t *offset)
{
        char *video = (char*)VIDEORAM;

        switch (ch) {
        case '\t':
                *offset += TABSIZE;
                break;
        case '\n':
                *offset += (COLS - ((*offset) % COLS));
                break;
        case '\r':
                *offset -= (*offset % COLS);
                break;
        default:
                video += (*offset << 1);
                *video++ = ch;
                *video = BGCOLOR;
                (*offset)++;
                break;
        }

        if (*offset == MAXCOL) {
                *offset = 0;
        }

        return 0;
}

static inline int dbg_vfprintf(off_t *offset, const char *format, va_list ap)
{
        int ret;
        int pntsz;
        register int i;
        register int j;
        const char *fmt;
        char *str;
        char ch;
        char digit[12];
        enum state {
                NORMAL,
                ARG,
        } state;

        i = 0;
        pntsz = 0;
        fmt = format;
        state = NORMAL;
        while (fmt[i]) {
                ch = fmt[i];

                switch (ch) {
                case '%':
                        state = ARG;
                        break;
                default:
                        if (state == NORMAL) {
                                dbg_putc(ch, offset);
                                pntsz++;
                                break;
                        }

                        switch (ch) {
                        case '%':
                                dbg_putc(ch, offset);
                                pntsz++;
                                break;
                        case 'p':
                                dbg_putc('0', offset);
                                dbg_putc('x', offset);
                                pntsz += 2;
                        case 'x':
                                j = hex_to_rstr(
                                        va_arg(ap, unsigned), digit);
                                while (j-- > 0) {
                                        ret = dbg_putc(digit[j], offset);
                                        if (ret < 0) {
                                                return ret;
                                        }
                                        pntsz++;
                                }
                                break;
                        case 'u':
                                j = unsigned_to_rstr(
                                        va_arg(ap, unsigned), digit);
                                while (j-- > 0) {
                                        ret = dbg_putc(digit[j], offset);
                                        if (ret < 0) {
                                                return ret;
                                        }
                                        pntsz++;
                                }
                                break;
                        case 'd':
                                j = signed_to_rstr(va_arg(ap, int), digit);
                                while (j-- > 0) {
                                        ret = dbg_putc(digit[j], offset);
                                        if (ret < 0) {
                                                return ret;
                                        }
                                        pntsz++;
                                }
                                break;
                        case 's':
                                str = (char*)va_arg(ap, char*);
                                while (*str) {
                                        ret = dbg_putc(*str++, offset);
                                        if (ret < 0) {
                                                return ret;
                                        }
                                        pntsz++;
                                }
                                break;
                        case 'c':
                                ch = (char)va_arg(ap, unsigned int);
                                ret = dbg_putc(ch, offset);
                                if (ret < 0) {
                                        return ret;
                                }
                                pntsz++;
                                break;
                        default:
                                break;
                        }

                        state = NORMAL;
                        break;
                }

                i++;
        }

        return pntsz;
}

int dbg_printf(const char *format, ...)
{
        va_list ap;
        static off_t offset = 0;
        int ret;

        va_start(ap, format);
        ret = dbg_vfprintf(&offset, format, ap);
        va_end(ap);

        return ret;
}

/* End of a file */