DAY 5

1) Asmhead.asm

; haribote-os

BOTPAK EQU 0x00280000 ; 加载 bootpack

DSKCAC EQU 0x00100000 ; 磁盘缓存的位置
DSKCAC0 EQU 0x00008000 ; 实模式磁盘缓存的位置

; 有关 BOOT_INFO
CYLS EQU 0x0ff0 ; 设置启动区
LEDS EQU 0x0ff1
VMODE EQU 0x0ff2 ; 关于颜色数目的信息，颜色的位数
SCRNX EQU 0x0ff4 ; 分辨率 X
SCRNY EQU 0x0ff6 ; 分辨率 Y
VRAM EQU 0x0ff8 ; 图像缓冲区的起始位置

; 使用 linker script 指定起始地址

ORG 0xc200 ; 程序被加载的内存地址

[BITS 16]
entry:
; 设置屏幕模式
MOV AL, 0x13 ; VGA 显卡，320x200x8 bit
MOV AH, 0x00
INT 0x10

MOV BYTE [VMODE], 8 ; 屏幕的模式

MOV WORD [SCRNX], 320
MOV WORD [SCRNY], 200
MOV DWORD [VRAM], 0x000a0000

; 用 BIOS 取得键盘上各种 LED 指示灯的状态

MOV AH, 0x02
INT 0x16 ; 键盘 BIOS
MOV [LEDS], AL
; 防止 PIC 接受所有中断
; 根据 AT 兼容机的规范初始化 PIC
; 如果没有在 CLI 指令前执行可能会挂起
; 并继续初始化 PIC
MOV AL, 0xff
OUT 0x21, AL
NOP ; 有些机器不能连续执行 NOP 指令
OUT 0xa1, AL

CLI

; 设置 A20GATE 使 CPU 支持 1M 以上的内存

CALL waitkbdout
MOV AL, 0xd1
OUT 0x64, AL
CALL waitkbdout
MOV AL, 0xdf ; 开启 A20
OUT 0x60, AL
CALL waitkbdout

; 切换到保护模式
LGDT [GDTR0] ; 设置临时 GDT
MOV EAX, CR0
AND EAX, 0x7fffffff ; 禁用分页
OR EAX, 0x00000001 ; 开启保护模式
MOV CR0, EAX
JMP pipelineflush

pipelineflush:
MOV AX, 1*8 ; 写 32bit 段
MOV DS, AX
MOV ES, AX
MOV FS, AX
MOV GS, AX
MOV SS, AX

; bootpack 传递
MOV ESI, bootpack ; 源
 MOV EDI, BOTPAK ; 目标
MOV ECX, 512*1024/4
CALL memcpy

; 传输磁盘数据

; 从引导区开始

MOV ESI, 0x7c00 ; 源

MOV EDI, DSKCAC ; 目标
MOV ECX, 512/4
CALL memcpy

; 剩余的全部
MOV ESI, DSKCAC0+512 ; 源
MOV EDI, DSKCAC+512 ; 目标
MOV ECX, 0
MOV CL, BYTE [CYLS]
IMUL ECX, 512*18*2/4 ; 除以 4 得到字节数
SUB ECX, 512/4 ; IPL 偏移量
CALL memcpy

skip:
MOV ESP, 0xffff
JMP DWORD 2*8:0x00000000

waitkbdout:
IN AL, 0x64
AND AL, 0x02
JNZ waitkbdout ; AND 结果不为 0 跳转至 waitkbdout
RET

memcpy:
MOV EAX, [ESI]
ADD ESI, 4
MOV [EDI], EAX
ADD EDI, 4
SUB ECX, 1
 JNZ memcpy ; 结果不为 0 跳转至 memcpy
RET
; memcpy 地址前缀大小

ALIGN 16
GDT0:
RESB 8 ; 初始值
DW 0xffff, 0x0000, 0x9200, 0x00cf ; 可写的 32 位段寄存器
DW 0xffff, 0x0000, 0x9a28, 0x0047 ; 可执行的文件的 32 位寄存器

DW 0

GDTR0:
DW 8*3-1
DD GDT0

ALIGN 16
bootpack:
2) Bootpack.c

#include <stdio.h>

#include "io.h"
#include "pm.h"

void init_palette(void);
void set_palette(int start, int end, unsigned char *rgb);
void box_fill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0,
int x1, int y1);
void init_screen(unsigned char *vram, int x, int y);
void put_font8(unsigned char *vram, int xsize, int x, int y, char c,
char *font);
void put_fonts8_asc(unsigned char *vram, int xsize, int x, int y, char c,
char *s);
void init_mouse_cursor8(char *mouse, char bc);
void put_block8_8(unsigned char *vram, int vxsize, int pxsize, int pysize,
int px0, int py0, char *buf, int bxsize);

#define COL8_000000 0
#define COL8_FF0000 1
#define COL8_00FF00 2
#define COL8_FFFF00 3
#define COL8_0000FF 4
#define COL8_FF00FF 5
#define COL8_00FFFF 6
#define COL8_FFFFFF 7
#define COL8_C6C6C6 8
#define COL8_840000 9
#define COL8_008400 10
#define COL8_848400 11
#define COL8_000084 12
#define COL8_840084 13
#define COL8_008484 14
#define COL8_848484 15
struct BootInfo {
char cyls, leds, vmode, reserve;
short scrnx, scrny;
unsigned char *vram;
};

struct SegmentDescriptor {
short limit_low, base_low;
char base_mid, access_right;
char limit_high, base_high;
};

struct GateDescriptor {
short offset_low, selector;
char dw_count, access_right;
short offset_high;
};

void init_gdtidt(void);
void set_segmdesc(struct SegmentDescriptor *sd, unsigned int limit, int base,
int ar);
void set_gatedesc(struct GateDescriptor *gd, int offset, int selector, int ar);

int main(void) {
struct BootInfo *binfo = (struct BootInfo *)0x0ff0;
char s[40], mcursor[256];

init_gdtidt();
init_palette();

init_screen(binfo->vram, binfo->scrnx, binfo->scrny);

int mx = (binfo->scrnx - 16) / 2;

int my = (binfo->scrny - 28 - 16) / 2;
init_mouse_cursor8(mcursor, COL8_008484);
put_block8_8(binfo->vram, binfo->scrnx, 16, 16, mx, my, mcursor, 16);

put_fonts8_asc(binfo->vram, binfo->scrnx, 8, 8, COL8_FFFFFF, "ABC 123");

 put_fonts8_asc(binfo->vram, binfo->scrnx, 31, 31, COL8_000000,
"Haribote OS.");
put_fonts8_asc(binfo->vram, binfo->scrnx, 30, 30, COL8_FFFFFF,
"Haribote OS.");

sprintf(s, "scrnx = %d", binfo->scrnx);

put_fonts8_asc(binfo->vram, binfo->scrnx, 16, 64, COL8_FFFFFF, s);

for (;;) {
io_hlt();
}

return 0;
}

void init_palette(void) {
static unsigned char table_rgb[16 * 3] = {
0x00, 0x00, 0x00, // 黑色
0xff, 0x00, 0x00, // 亮红色
0x00, 0xff, 0x00, // 亮绿色
0xff, 0xff, 0x00, // 亮黄色
0x00, 0x00, 0xff, // 亮蓝色
0xff, 0x00, 0xff, // 亮紫色
0x00, 0xff, 0xff, // 浅亮蓝色
0xff, 0xff, 0xff, // 白色
0xc6, 0xc6, 0xc6, // 亮灰色
0x84, 0x00, 0x00, // 暗红色
0x00, 0x84, 0x00, // 暗绿色
0x84, 0x84, 0x00, // 暗黄色
0x00, 0x00, 0x84, // 暗蓝色
0x84, 0x00, 0x84, // 暗紫色
0x00, 0x84, 0x84, // 浅暗蓝色
0x84, 0x84, 0x84 // 暗灰色
};

set_palette(0, 15, table_rgb);

}
void set_palette(int start, int end, unsigned char *rgb) {
int eflags = io_load_eflags(); // 记录标志

io_cli(); // 禁止中断

io_out8(0x03c8, start);
for (int i = start; i <= end; i++) {
io_out8(0x03c9, rgb[0] / 4);
io_out8(0x03c9, rgb[1] / 4);
io_out8(0x03c9, rgb[2] / 4);
rgb += 3;
}

io_store_eflags(eflags);
}

void box_fill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0,
int x1, int y1) {
for (int y = y0; y <= y1; y++) {
for (int x = x0; x <= x1; x++) {
vram[y * xsize + x] = c;
}
}
}

void init_screen(unsigned char *vram, int x, int y) {

box_fill8(vram, x, COL8_008484, 0, 0, x - 1, y - 29);
box_fill8(vram, x, COL8_C6C6C6, 0, y - 28, x - 1, y - 28);
box_fill8(vram, x, COL8_FFFFFF, 0, y - 27, x - 1, y - 27);
box_fill8(vram, x, COL8_C6C6C6, 0, y - 26, x - 1, y - 1);

box_fill8(vram, x, COL8_FFFFFF, 3, y - 24, 59, y - 24);

box_fill8(vram, x, COL8_FFFFFF, 2, y - 24, 2, y - 4);
box_fill8(vram, x, COL8_848484, 3, y - 4, 59, y - 4);
box_fill8(vram, x, COL8_848484, 59, y - 23, 59, y - 5);
box_fill8(vram, x, COL8_000000, 2, y - 4, 59, y - 3);
box_fill8(vram, x, COL8_000000, 60, y - 24, 60, y - 3);
 box_fill8(vram, x, COL8_848484, x - 47, y - 24, x - 4, y - 24);
box_fill8(vram, x, COL8_848484, x - 47, y - 23, x - 47, y - 4);
box_fill8(vram, x, COL8_FFFFFF, x - 47, y - 3, x - 4, y - 3);
box_fill8(vram, x, COL8_FFFFFF, x - 3, y - 24, x - 3, y - 3);
}

void put_font8(unsigned char *vram, int xsize, int x, int y, char c,

char *font) {
unsigned char *p;
char d;

for (int i = 0; i < 16; i++) {

p = vram + (y + i) * xsize + x;
d = font[i];

if ((d & 0x80) != 0) {

p[0] = c;
}

if ((d & 0x40) != 0) {

p[1] = c;
}

if ((d & 0x20) != 0) {

p[2] = c;
}

if ((d & 0x10) != 0) {

p[3] = c;
}

if ((d & 0x08) != 0) {

p[4] = c;
}

if ((d & 0x04) != 0) {

p[5] = c;
}
 if ((d & 0x02) != 0) {
p[6] = c;
}

if ((d & 0x01) != 0) {

p[7] = c;
}
}
}

void put_fonts8_asc(unsigned char *vram, int xsize, int x, int y, char c,

char *s) {
extern char hankaku[4096];

for (; *s != '\0'; s++) {

put_font8(vram, xsize, x, y, c, hankaku + *s * 16);
x += 8;
}
}

void init_mouse_cursor8(char *mouse, char bc) {

static char cursor[16][16] = {
"**************..",
"*OOOOOOOOOOO*...",
"*OOOOOOOOOO*....",
"*OOOOOOOOO*.....",
"*OOOOOOOO*......",
"*OOOOOOO*.......",
"*OOOOOOO*.......",
"*OOOOOOOO*......",
"*OOOO**OOO*.....",
"*OOO*..*OOO*....",
"*OO*....*OOO*...",
"*O*......*OOO*..",
"**........*OOO*.",
"*..........*OOO*",
"............*OO*",
 ".............***"};

for (int y = 0; y < 16; y++) {

for (int x = 0; x < 16; x++) {
if (cursor[y][x] == '*') {
mouse[y * 16 + x] = COL8_000000;
}

if (cursor[y][x] == 'O') {
mouse[y * 16 + x] = COL8_FFFFFF;
}

if (cursor[y][x] == '.') {
mouse[y * 16 + x] = bc;
}
}
}
}

void put_block8_8(unsigned char *vram, int vxsize, int pxsize, int pysize,
int px0, int py0, char *buf, int bxsize) {
for (int y = 0; y < pysize; y++) {
for (int x = 0; x < pxsize; x++) {
vram[(py0 + y) * vxsize + (px0 + x)] = buf[y * bxsize + x];
}
}
}

void init_gdtidt(void) {
struct SegmentDescriptor *gdt = (struct SegmentDescriptor *)0x00270000;
struct GateDescriptor *idt = (struct GateDescriptor *)0x0026f800;

for (int i = 0; i < 8192; i++) {

set_segmdesc(gdt + i, 0, 0, 0);
}

set_segmdesc(gdt + 1, 0xffffffff, 0x00000000, 0x4092);

set_segmdesc(gdt + 2, 0x0007ffff, 0x00280000, 0x409a);
 load_gdtr(0xffff, 0x00270000);

for (int i = 0; i < 256; i++) {

set_gatedesc(idt + i, 0, 0, 0);
}
load_idtr(0x7ff, 0x0026f800);
}

void set_segmdesc(struct SegmentDescriptor *sd, unsigned int limit, int base,

int ar) {
if (limit > 0xfffff) {
ar |= 0x8000; // G_bit = 1
limit /= 0x1000;
}

sd->limit_low = limit & 0xffff;

sd->base_low = base & 0xffff;
sd->base_mid = (base >> 16) & 0xff;
sd->access_right = ar & 0xff;
sd->limit_high = ((limit >> 16) & 0x0f) | ((ar >> 8) | 0xf0);
sd->base_high = (base >> 24) & 0xff;
}

void set_gatedesc(struct GateDescriptor *gd, int offset, int selector, int ar) {
gd->offset_low = offset & 0xffff;
gd->selector = selector;
gd->dw_count = (ar >> 8) & 0xff;
gd->access_right = ar & 0xff;
gd->offset_high = (offset >> 16) & 0xffff;
}
3) io.asm

[BITS 32]

; 程序中包含函数名
GLOBAL io_hlt, io_cli, io_sti, io_stihlt
GLOBAL io_in8, io_in16, io_in32
GLOBAL io_out8, io_out16, io_out32
GLOBAL io_load_eflags, io_store_eflags

[SECTION .text]
io_hlt: ; void io_hlt(void);
HLT
RET

io_cli: ; void io_cli(void);

CLI
RET

io_sti: ; void io_sti(void);

STI
RET

io_stihlt: ; void io_stihlt(void);

STI
HLT
RET

io_in8: ; int io_in8(int port);

MOV EDX, [ESP+4] ; port
MOV EAX, 0
IN AL, DX
RET

io_in16: ; int io_in16(int port);

MOV EDX, [ESP+4] ; port
MOV EAX, 0
IN AX, DX
RET

io_in32: ; int io_in32(int port);

MOV EDX, [ESP+4] ; port
IN EAX, DX
RET

io_out8: ; void io_out8(int port, int data);

MOV EDX, [ESP+4] ; port
MOV AL, [ESP+8] ; data
OUT DX, AL
 RET

io_out16: ; void io_out16(int port, int data);

MOV EDX, [ESP+4] ; port
MOV AX, [ESP+8] ; data
OUT DX, AX
RET

io_out32: ; void io_out32(int port, int data);

MOV EDX, [ESP+4] ; port
MOV EAX, [ESP+8] ; data
OUT DX, EAX
RET

io_load_eflags: ; int io_load_eflags(void);

PUSHFD
POP EAX
RET

io_store_eflags: ; void io_store_eflags(int eflags);

MOV EAX, [ESP+4] ; eflags
PUSH EAX
POPFD
RET

4) io.h

#ifndef _IO_H_
#define _IO_H_

void io_hlt(void);
void io_cli(void);
void io_sti(void);
void io_stihlt(void);

int io_in8(int port);

int io_in16(int port);
int io_in32(int port);

void io_out8(int port, int data);

void io_out16(int port, int data);
void io_out32(int port, int data);

int io_load_eflags(void);
void io_store_eflags(int eflags);

#endif // _IO_H_

5) ipl.asm

; hello-os

CYLS EQU 10 ; 读取的柱面数量（CYLS = cylinders）

ORG 0x7c00 ; 指明程序的装载地址

; 用于标准 FAT12 格式的软盘

JMP entry ; 跳转指令
NOP ; NOP 指令
 DB "HARIBOTE" ; OEM 标识符（8 字节）
DW 512 ; 每个扇区（sector）的字节数（必须为 512 字节）
DB 1 ; 每个簇（cluster）的扇区数（必须为 1 个扇区）
DW 1 ; FAT 的预留扇区数（包含 boot 扇区）
DB 2 ; FAT 表的数量，通常为 2
DW 224 ; 根目录文件的最大值（一般设为 224 项）
DW 2880 ; 磁盘的扇区总数，若为 0 则代表超过 65535 个扇区，
需要使用 22 行记录
DB 0xf0 ; 磁盘的种类（本项目中设为 0xf0 代表 1.44MB 的软盘）
DW 9 ; 每个 FAT 的长度（必须为 9 扇区）
DW 18 ; 1 个磁道（track）拥有的扇区数（必须是 18）
DW 2 ; 磁头数（必须为 2）
DD 0 ; 隐藏的扇区数
DD 2880 ; 大容量扇区总数，若 16 行记录的值为 0 则使用本行记
录扇区数
DB 0 ; 中断 0x13 的设备号
DB 0 ; Windows NT 标识符
DB 0x29 ; 扩展引导标识
DD 0xffffffff ; 卷序列号
DB "HARIBOTEOS " ; 卷标（11 字节）
DB "FAT12 " ; 文件系统类型（8 字节）
RESB 18 ; 空 18 字节

; 程序核心

entry:
MOV AX, 0 ; 初始化寄存器
MOV SS, AX
MOV SP, 0x7c00
MOV DS, AX

; 读取硬盘
MOV AX, 0x0820
MOV ES, AX
MOV CH, 0 ; 柱面 0
MOV DH, 0 ; 磁头 0
MOV CL, 2 ; 扇区 2
readloop:
MOV SI, 0 ; 记录失败次数的寄存器
retry:
MOV AH, 0x02 ; AH=0x02：读盘
MOV AL, 1 ; 1 个扇区
MOV BX, 0
MOV DL, 0x00 ; A 驱动器
INT 0x13 ; 调用磁盘 BIOS
JNC next ; 没出错跳转到 next

ADD SI, 1 ; 失败次数+1

CMP SI, 5 ; 失败次数是否达到 5 次
JAE error ; 失败次数达到 5 次跳转到 error
MOV AH, 0x00
MOV DL, 0x00 ; A 驱动器
INT 0x13 ; 重置驱动器
JMP retry

next:
MOV AX, ES ; 把内存地址后移 0x200
ADD AX, 0x0020
MOV ES, AX ; 实现 ES += 0x0020 的目的

; 扇区范围 1～18
ADD CL, 1 ; 扇区加 1
CMP CL, 18 ; 扇区是否达到 18
JBE readloop ; 小于等于 18 扇区则跳转到 readloop

MOV CL, 1 ; 恢复到扇区 1

; 磁头范围 0～1（正面 0，反面 1）
ADD DH, 1
CMP DH, 2
JB readloop ; 磁头未达到 2 则跳转到 readloop

MOV DH, 0
; 柱面范围 0 ～ 79
ADD CH, 1
CMP CH, CYLS
 JB readloop ; 读取指定数量的柱面，未达到 CYLS 则跳转 readloop

; 读取完毕，跳转到 haribote.sys 执行
MOV [0x0ff0], CH ; 记下 IPL 读了多远（谷歌翻译自 IPL がどこまで読ん
だのかをメモ）
JMP 0xc200

fin:
HLT ; CPU 停止，等待指令
JMP fin ; 无限循环

error:
MOV SI, msg

putloop:
MOV AL, [SI]
ADD SI, 1 ; SI 加 1
CMP AL, 0

JE fin
MOV AH, 0x0e ; 显示一个文字
MOV BX, 15 ; 指定字符颜色
INT 0x10 ; 调用显卡 BIOS
JMP putloop

msg:
DB 0x0a, 0x0a ; 两个换行
DB "load error"
DB 0x0a ; 换行
DB 0

RESB 0x1fe - ($ - $$) ; 填写 0x00，直到 0x001fe

DB 0x55, 0xaa
6) kernel.ld

ENTRY( main )

MEMORY
{
rom : ORIGIN = 0x000000, LENGTH = 0x280000
ram : ORIGIN = 0x280000, LENGTH = 0x020000
}

SECTIONS
{
. = 0x0000;
 .text :
{
*(.text.main);
*(.text);
} > rom AT > ram

.rodata :
{
*(.rodata)
} > ram

.data :
{
*(.data)
} > ram

.bss :
{
*(.bss)
} > ram
}

7) Makefile

ifndef GCCPREFIX
GCCPREFIX :=
endif

AS := nasm
CC := $(GCCPREFIX)gcc
LD := $(GCCPREFIX)ld
OBJCOPY := $(GCCPREFIX)objcopy
QEMU := qemu-system-i386

CFLAGS += -Wall -Wno-format -Wno-unused

CFLAGS += -std=gnu99 -static -m32
CFLAGS += -I./libc/include
CFLAGS += -ffunction-sections -nostdlib -nostdinc -fno-builtin -ffreestanding
CFLAGS += -fno-pie

QEMU_FLAGS += -no-reboot -d in_asm

# C Library Objects
L_OBJS := libc/stdio/stdio.bin
# Kernel Objects
K_OBJS := bootpack.bin io.bin pm.bin hankaku.bin
SYS := haribote.sys
IMG := haribote.img

ifdef DEBUG
QEMU_FLAGS += -gdb tcp::1234 -S
CFLAGS += -g
endif

ipl.bin:
$(AS) -f bin ipl.asm -o ipl.bin -l ipl.lst

asmhead.bin:
$(AS) -f bin asmhead.asm -o asmhead.bin -l asmhead.lst

hankaku.bin: ../hankaku/hankaku.asm
$(AS) -f elf $< -o $@

%.bin: %.asm
$(AS) -f elf $< -o $@ -l $(subst .asm,.lst,$<)

%.bin: %.c
$(CC) $(CFLAGS) -c $< -o $@

kernel.sys: ${K_OBJS} ${L_OBJS}

$(LD) -m elf_i386 --oformat binary -o kernel.sys -T kernel.ld $^

haribote.sys: asmhead.bin kernel.sys

 cat asmhead.bin > haribote.sys
cat kernel.sys >> haribote.sys

image: ipl.bin haribote.sys

dd if=/dev/zero of=$(IMG) bs=512 count=2880
dd if=ipl.bin of=$(IMG) bs=512 count=1 conv=notrunc
dd if=haribote.sys of=$(IMG) seek=33 bs=512 conv=notrunc

all: ${OBJS} haribote.sys image

clean:
rm -rf *.bin
rm -rf *.sys
rm -rf *.obj
rm -rf *.lst
rm -rf $(IMG)
rm -rf **/**/*.bin

qemu: clean all

$(QEMU) -fda $(IMG) $(QEMU_FLAGS)

.PHONY:
all

8) pm.asm

[BITS 32]

GLOBAL load_gdtr, load_idtr

[SECTION .text]
load_gdtr: ; void load_gdt(int limit, int addr);
MOV AX, [ESP+4] ; limit
MOV [ESP+6], AX
LGDT [ESP+6]
RET

load_idtr: ; void load_idt(int limit, int addr);

 MOV AX, [ESP+4] ; limit
MOV [ESP+6], AX
LIDT [ESP+6]
RET

9) pm.h

#ifndef _PM_H_
#define _PM_H_

void load_gdtr(int limit, int addr);

void load_idtr(int limit, int addr);

#endif // _PM_H_
 Libc
1) include
a) stdarg.h

#ifndef _STDARG_H
#define _STDARG_H

typedef __builtin_va_list va_list;

#define va_start(ap, last) __builtin_va_start(ap, last)

#define va_arg(ap, type) __builtin_va_arg(ap, type)

#define va_end(ap) __builtin_va_end(ap)

#endif // _STDARG_H

b) stdio.h

#ifndef _STDIO_H
#define _STDIO_H

#include <stdarg.h>

#ifndef NULL
#define NULL ((void *)0)
#endif // NULL

int sprintf(char *s, const char *format, ...);

int vsprintf(char *s, const char *format, va_list args);

#endif // _STDIO_H

Libc
2) stdio.c

#include <stdarg.h>
#include <stdio.h>

struct SprintBuf {
char *buf;
int count;
};

void printnum(void (*fputch)(char, void *), void *data, unsigned long num,
int base) {
if (num >= base) {
 printnum(fputch, data, num / base, base);
}

fputch("0123456789abcdef"[num % base], data);

}

void vprintfmt(void (*fputch)(char, void *), void *data, const char *fmt,
va_list ap) {
int ch;
unsigned long long num;
char *str;

while (1) {
while ((ch = *fmt++) != '%') {
fputch(ch, data);
if (ch == '\0') {
return;
}
}

num = 0;
switch (ch = *fmt++) {
case 'c':
fputch(va_arg(ap, int), data);
break;

case 'd':
num = va_arg(ap, int);
if ((long long)num < 0) {
fputch('-', data);
num = -(long long)num;
}
printnum(fputch, data, num, 10);
break;

case 'p':
fputch('0', data);
fputch('x', data);
 num = (unsigned long)va_arg(ap, void *);
printnum(fputch, data, num, 16);
break;

case 's':
str = va_arg(ap, char *);
if (str == NULL) {
str = "<null>";
}
while (*str != '\0') {
fputch(*str, data);
str++;
}
break;

case '%':
fputch('%', data);
break;

default:
break;
}
}
}

void sprint_putch(char c, struct SprintBuf *data) {

*data->buf++ = c;
data->count++;
}

int vsprintf(char *s, const char *format, va_list ap) {

struct SprintBuf buf = {s, 0};

vprintfmt((void *)sprint_putch, &buf, format, ap);

return buf.count;
}
int sprintf(char *s, const char *format, ...) {
va_list ap;
int ret;

va_start(ap, format);
ret = vsprintf(s, format, ap);
va_end(ap);

return ret;
}