osdev/kernel_stdio.c at master · cstack/osdev · 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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
#include"kernel_stdio.h"

#include"drivers/frame_buffer.h"
#include"drivers/serial_port.h"

#include"stdarg.h"

typedefvoid (*write_byte_t)(uint8_t);

write_byte_twrite_byte_function(FILEstream) {
switch (stream) {
case (SCREEN):
returnfb_write_byte;
case (LOG):
returnserial_write_byte;
 }
}

voidkernel_write_half_byte(write_byte_twrite_byte, uint8_thalf_byte, boolupcase) {
switch (half_byte) {
case0x0:
write_byte('0');
break;
case0x1:
write_byte('1');
break;
case0x2:
write_byte('2');
break;
case0x3:
write_byte('3');
break;
case0x4:
write_byte('4');
break;
case0x5:
write_byte('5');
break;
case0x6:
write_byte('6');
break;
case0x7:
write_byte('7');
break;
case0x8:
write_byte('8');
break;
case0x9:
write_byte('9');
break;
case0xA:
write_byte(upcase ? 'A' : 'a');
break;
case0xB:
write_byte(upcase ? 'B' : 'b');
break;
case0xC:
write_byte(upcase ? 'C' : 'c');
break;
case0xD:
write_byte(upcase ? 'D' : 'd');
break;
case0xE:
write_byte(upcase ? 'E' : 'e');
break;
case0xF:
write_byte(upcase ? 'F' : 'f');
break;
 }
}

voidkernel_write_string(write_byte_twrite_byte, char*s) {
while(*s) {
write_byte(*s);
s++;
 }
}

voidkernel_write_uint(write_byte_twrite_byte, uint32_tvalue) {
if (value==0) {
write_byte('0');
return;
 }

charoutput[10];
for (intplace=0; place<10; place++) {
output[place] =value % 10;
value=value / 10;
 }

boolpast_leading_zeroes= false;
for (intplace=9; place >= 0; place--) {
if (output[place] >0) {
past_leading_zeroes= true;
 }

if (past_leading_zeroes) {
write_byte(output[place] +'0');
 }
 }
}

voidkernel_write_int(write_byte_twrite_byte, intvalue) {
if (value<0) {
write_byte('-');
value *= -1;
 }
kernel_write_uint(write_byte, value);
}

voidkernel_write_octal(write_byte_twrite_byte, uint32_tvalue) {
write_byte('0');
write_byte('o');
boolpast_leading_zeroes= false;
uint8_tpart= (value >> 30) &0b11;
if (part>0) {
kernel_write_half_byte(write_byte, part, true);
past_leading_zeroes= true;
 }
for (inti=10; i >=0; i--) {
part= (value >> (3*i)) &0b111;
if (part>0) {
past_leading_zeroes= true;
 }

if (past_leading_zeroes) {
kernel_write_half_byte(write_byte, part, true);
 }
 }
}

enumformat_string_mode {NORMAL, COMMAND};
intfprintf (FILEstream, constchar*format, ...) {
write_byte_twrite_byte=write_byte_function(stream);

va_listvl;
va_start(vl,format);

inti=0;
enumformat_string_modemode=NORMAL;
uint32_tvararg;
while (format[i]) {
switch (mode) {
case (NORMAL):
if (format[i] =='%') {
mode=COMMAND;
 } else {
write_byte(format[i]);
 }
break;
case (COMMAND):
if (format[i] =='%') {
write_byte('%');
 } elseif (format[i] =='c') {
write_byte((uint32_t) va_arg(vl,uint32_t));
 } elseif (format[i] =='i'||format[i] =='d') {
kernel_write_int(write_byte, va_arg(vl, int));
 } elseif (format[i] =='o') {
kernel_write_octal(write_byte, va_arg(vl, int));
 } elseif (format[i] =='s') {
kernel_write_string(write_byte, (char*) va_arg(vl,char*));
 } elseif (format[i] =='u') {
kernel_write_uint(write_byte, va_arg(vl, uint32_t));
 } elseif (format[i] =='x') {
write_byte('0');
write_byte('x');
vararg=va_arg(vl,uint32_t);
for (inti=7; i >=0; i--) {
kernel_write_half_byte(write_byte, (vararg >> (4*i)) &0x0F, false);
 }
 } elseif (format[i] =='X') {
write_byte('0');
write_byte('x');
vararg=va_arg(vl,uint32_t);
for (inti=7; i >=0; i--) {
kernel_write_half_byte(write_byte, (vararg >> (4*i)) &0x0F, true);
 }
 } else {
write_byte('?');
mode=NORMAL;
 }
mode=NORMAL;
break;
 }
i++;
 }
returni;
}