stdarg.c

Go to the documentation of this file.

#include <stdint.h>
#include <stddef.h>
#include <sys/types.h>
#include <stdio.h>
#include <stdarg.h>
#include <ctype.h>
#include <string.h> /* strlen */
#include <errno.h>

#include <object.h>
#include <list.h>
#include <pthread_mutex.h>
#include <thread.h>
#include <crt0.h>

#define MAX_DIGIT_LEN 14

struct info {
        union {
                FILE *stream;
                struct {
                        char *ptr;
                        size_t sz;
                        int idx;
                } buffer;
        } out;

        enum {
                STREAM = 0x00,
                BUFFER = 0x01,
        } type;
};

static inline int hex_to_str(unsigned d, char *out)
{
        const char *hex_table = "0123456789abcdef";
        int ret;
        char tmp[MAX_DIGIT_LEN];
        int i;

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

        tmp[ret++] = hex_table[(d % 16)];

        i = ret;
        while (i > 0) {
                *out++ = tmp[--i];
        }

        return ret;
}

static inline int unsigned_to_str(unsigned d, char *out)
{
        int ret;
        char tmp[MAX_DIGIT_LEN];
        int i;

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

        tmp[ret++] = (d % 10) + '0';

        i = ret;
        while (i > 0) {
                *out++ = tmp[--i];
        }

        return ret;
}

static inline int signed_to_str(int d, char *out)
{
        int ret;
        char tmp[MAX_DIGIT_LEN];
        int i;
        char *ptr;

        ptr = out;
        if (d < 0) {
                d = -d;
                *ptr++ = '-';
        }

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

        tmp[ret++] = (d % 10) + '0';

        i = ret;
        while (i > 0) {
                *ptr++ = tmp[--i];
        }

        return (int)(ptr - out);
}

static inline int fill_space(struct info *info, char ch, int len)
{
        register int i;

        for (i = 0; i < len && info->out.buffer.idx < info->out.buffer.sz; i++) {
                if (info->type == BUFFER) {
                        info->out.buffer.ptr[info->out.buffer.idx++] = ch;
                } else {
                        fputc(ch, info->out.stream);
                }
        }

        return i;
}

static inline int fmt_write(struct info *info, const char *ch, int len)
{
        register int i;

        for (i = 0; i < len && info->out.buffer.idx < info->out.buffer.sz; i++) {
                if (info->type == BUFFER) {
                        info->out.buffer.ptr[info->out.buffer.idx++] = *ch;
                } else {
                        fputc(*ch, info->out.stream);
                }

                ch++;
        }

        return i;
}

static inline int fmt_parser(struct info *info, const char *format, va_list ap)
{
        int pntsz;
        const char *fmt;
        int len;
        int ext_step;
        int fill_zero;
        char digit_buffer[MAX_DIGIT_LEN];
        register int i;
        char *buffer;
        enum {
                NORMAL,
                ARG,
                INFO,
                OPT,
        } state;

        pntsz = 0;
        state = NORMAL;
        for (fmt = format; *fmt; fmt++) {
                switch (state) {
                case ARG:
                        if (*fmt == '%') {
                                state = NORMAL;
                                buffer = (char *)fmt;
                                i = 1;
                                break;
                        }

                        fill_zero = (*fmt == '.');
                        if (fill_zero) {
                                state = INFO;
                        } else if (isdigit(*fmt)) {
                                state = INFO;
                                fmt--;
                        } else {
                                state = OPT;
                                fmt--;
                        }

                        continue;
                case INFO:
                        if (isdigit(*fmt)) {
                                len = len * 10 + (*fmt - '0');
                                continue;
                        }

                        state = OPT;
                        ext_step = 0;
                        fmt--;
                        continue;
                case OPT:
                        buffer = digit_buffer;

                        switch (*fmt) {
                        case 'f':
                        case 'F':
                                /* unsupported */
                                return -ENOSYS;
                        case 'l':
                                if (ext_step > 1) {
                                        return -EINVAL;
                                }

                                ext_step++;
                                continue;
                        case 'd':
                        case 'D':
                                i = signed_to_str(va_arg(ap, int), buffer);
                                break;
                        case 'x':
                        case 'X':
                                i = hex_to_str(va_arg(ap, int), buffer);
                                break;
                        case 'u':
                        case 'U':
                                i = unsigned_to_str(va_arg(ap, unsigned), buffer);
                                break;
                        case 'p':
                        case 'P':
                                buffer[0] = '0';
                                buffer[1] = 'x';
                                i = hex_to_str(va_arg(ap, unsigned), buffer + 2);
                                break;
                        case 's':
                        case 'S':
                                buffer = va_arg(ap, char *);
                                i = buffer ? strlen(buffer) : 0;
                                break;
                        case 'c':
                        case 'C':
                                buffer[0] = (char)va_arg(ap, int);
                                i = 1;
                                break;
                        default:
                                return -EINVAL;
                        }

                        state = NORMAL;
                        pntsz += fill_space(info, (fill_zero ? '0' : ' '), len - i);
                        break;
                case NORMAL:
                default:
                        if (*fmt == '%') {
                                state = ARG;
                                len = 0;
                                continue;
                        }

                        i = 1;
                        buffer = (char *)fmt;
                        break;
                }

                pntsz += fmt_write(info, buffer, i);
        }

        return pntsz;
}

int vprintf(const char *format, va_list ap)
{
        int ret;

        ret = vfprintf(stdout, format, ap);

        return ret;
}

int vsprintf(char *str, const char *format, va_list ap)
{
        int ret;

        ret = vsnprintf(str, 0x7FFFFFFF, format, ap);

        return ret;
}

int vfprintf(FILE *stream, const char *format, va_list ap)
{
        struct info info;

        info.out.stream = stream;
        info.type = STREAM;

        return fmt_parser(&info, format, ap);
}

int vsnprintf(char *outbuf, size_t size, const char *format, va_list ap)
{
        struct info info;

        info.out.buffer.ptr = outbuf;
        info.out.buffer.sz = size;
        info.out.buffer.idx = 0;
        info.type = BUFFER;

        return fmt_parser(&info, format, ap);
}

/* End of a file */