mimic_os/common.c at master · DarrenKwonDev/mimic_os · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include "common.h"

//-----------------------------------------
// 전방 선언
void putchar(char ch);


//----------------------------------------
// 함수 정의

// buf fill c, n bytes
void *memset(void *buf, char c, size_t n)
{
    uint8_t *p = (uint8_t *)buf;
    while(n--)
        *p++ = c;
    return buf;
}


// src to dst copy, n bytes
void *memcpy(void *dst, const void *src, size_t n)
{
    uint8_t *d = (uint8_t *)dst;
    const uint8_t *s = (const uint8_t *)src;
    while(n--)
        *d++ = *s++;
    return dst;
}

// copy src to dst
void *strcpy(char *dst, const char *src)
{
    char *d = dst;
    while (*src)
        *d++ = *src++;
    *d = '\0';
    return dst;
}

// cmp s1 - s2 > 0, lexicographical order. e.g. 'a' > 'b'
int strcmp(const char *s1, const char *s2)
{
    while (*s1 && *s2)
    {
        if (*s1 != *s2)
            break;
        s1++;
        s2++;
    }
    return *(unsigned char *)s1 - *(unsigned char *)s2;
}

void printf(const char *fmt, ...)
{
    va_list vargs;
    va_start(vargs, fmt);

    while(*fmt)
    {
        if (*fmt == '%')
        {
            fmt++; // skip %

            switch (*fmt)
            {
                case '\0':
                    {
                        putchar('%');
                        goto end;
                    }

                case '%':
                    {
                        putchar('%');
                        break;
                    }

                case 's':
                    {
                        const char *s = va_arg(vargs, const char *);
                        while (*s)
                        {
                            putchar(*s);
                            s++;
                        }
                        break;
                    }

                case 'd':
                    {
                        /*
                           INT_MAX는 2,147,483,647 (0x7FFFFFFF)
                           INT_MIN은 -2,147,483,648 (0x80000000)

                           단순히 value = -value 꼴로 변경한다면
                           INT_MIN의 경우 2,147,483,648 이 되는데 이는 INT_MAX를 넘긴 값이 됨.

                           unsigned를 통해서 처리해야 바른 값을 표현할 수 있음
                        */
                        int value = va_arg(vargs, int);
                        unsigned magnitude = value;

                        if (value < 0)
                        {
                            putchar('-');
                            magnitude = -magnitude;
                        }

                        // 가장 큰 자릿수를 찾습니다
                        unsigned divisor = 1;
                        while(magnitude / divisor > 9)
                            divisor *= 10;

                        // 큰 자릿수부터 순차적으로 출력
                        while(divisor > 0)
                        {
                            putchar('0' + magnitude / divisor); // turn number to char
                            magnitude %= divisor;
                            divisor /= 10;
                        }

                        break;
                    }

                case 'x':
                    {
                        /*
                           4bit(nibble) 씩 옮겨서 16진수로 만듦
                        */
                        unsigned value = va_arg(vargs, unsigned);
                        for (int i = 7; i >= 0; i--)
                        {
                            unsigned nibble = (value >> (i * 4)) & 0xf;
                            putchar("0123456789abcdef"[nibble]);
                        }
                    }

            }
        }
        else
        {
            putchar(*fmt);
        }

        fmt++;

    }


end:
    va_end(vargs);
}