弄了好久，才发现一件重要的事情，原来是忘了汉字字库的制作和汉字的显示的有关详情

要显示汉字有点关键的东西不得不提

比如这段代码

#include <stdio.h>

int main(void) {
	printf("世界，你好！");
}

 编译后是这样的

问题究竟出在哪里呢，其实这还真是最有难度的地方，因为很少有人说（我也是从网上看了很多资料才幡然醒悟的） 

原来问题的关键竟在编码方式上，真是让人……，我们其实什么错也没有。改了编码后，重新输入中文，再编译一下试试。

 

当然我们的系统在写代码的时候也存在同样的问题，大家一定要把编码方式改成gb2312，否则是无法正确显示的。 

还有一个关键的问题是，为什么显示汉字的程序是那样的（问的好，说明的你的平台也搭建成功了）

void makefont16 (int color, int x, int y, short *font) {
	int *myfb = (int *)0xe0000000;
	int xsize = 800;
	short d;
	int *p;
	int i;
	for (i = 0; i < 16; i++){
		p = myfb + (y + i) * xsize + x;
		d = font[i];
		if ((d & 0x80) != 0) {p[0] = color;}
		if ((d & 0x40) != 0) {p[1] = color;}
		if ((d & 0x20) != 0) {p[2] = color;}
		if ((d & 0x10) != 0) {p[3] = color;}
		if ((d & 0x08) != 0) {p[4] = color;}
		if ((d & 0x04) != 0) {p[5] = color;}
		if ((d & 0x02) != 0) {p[6] = color;}
		if ((d & 0x01) != 0) {p[7] = color;}
		if ((d & 0x8000) != 0) {p[8] = color;}
		if ((d & 0x4000) != 0) {p[9] = color;}
		if ((d & 0x2000) != 0) {p[10] = color;}
		if ((d & 0x1000) != 0) {p[11] = color;}
		if ((d & 0x800) != 0) {p[12] = color;}
		if ((d & 0x400) != 0) {p[13] = color;}
		if ((d & 0x200) != 0) {p[14] = color;}
		if ((d & 0x100) != 0) {p[15] = color;}
	}
	return;
}

这当然没有什么好的方法，其实开始是很艰难的，在仿照30天自制操作系统时，我花了很长时间，用那个编码一点一点慢慢实验出来的（先是在屏幕上画横，然后是竖，然后试着画字库中的我，等等。这也算是真刀真枪、吭吭哧哧编程的开始吧，所以会有很多抄袭的痕迹，当然还是那句话，我对自己要求不高，毕竟有句话叫“天下文章一大抄”吗，菜鸟要想搞这个，开始是少不了抄袭的，这应该算是知识积累吧） 

系统的效果图运行效果图

从https://www.cnblogs.com/wunaozai/p/3858473.html这里下载   《工具集》真的要感谢这篇文章，再次感谢了

大约在这个网页的中下部 HZK编码链接

打开压缩包，把HZK16拷贝到自己工作目录

从30天自制操作系统的工具目录中复制bin2obj.exe到自己的工作目录

在工作目录运行bin2obj.exe

则字库文件生成完成

当然可以自己创建文件生成自己的字库

global _font0
_font0:
; 我
db 0x04,0x40,0x0E,0x50,0x78,0x48,0x08,0x48,0x08,0x40,0xFF,0xFE,0x08,0x40,0x08,0x44
db 0x0A,0x44,0x0C,0x48,0x18,0x30,0x68,0x22,0x08,0x52,0x08,0x8A,0x2B,0x06,0x10,0x02
; 爱
db 0x00,0x08,0x01,0xFC,0x7E,0x10,0x22,0x10,0x11,0x20,0x7F,0xFE,0x42,0x02,0x82,0x04
db 0x7F,0xF8,0x04,0x00,0x07,0xF0,0x0A,0x10,0x11,0x20,0x20,0xC0,0x43,0x30,0x1C,0x0E
; 你
db 0x08,0x80,0x08,0x80,0x08,0x80,0x11,0xFE,0x11,0x02,0x32,0x04,0x34,0x20,0x50,0x20
db 0x91,0x28,0x11,0x24,0x12,0x24,0x12,0x22,0x14,0x22,0x10,0x20,0x10,0xA0,0x10,0x40

手动编译方法是 nasm -felf -o font0.o font0.s 不能使用nasm -fbin -o font0.bin font0.s

以下是我内核的代码和编译方法（环境的搭建就省去了，有兴趣的请看系列文章的环境搭建0.01或视频）

kernel.c

typedef char * va_list;

#ifdef  __cplusplus
#define _ADDRESSOF(v)   ( &reinterpret_cast<const char &>(v) )
#else
#define _ADDRESSOF(v)   ( &(v) )
#endif

#define _INTSIZEOF(n)   ( (sizeof(n) + sizeof(int) - 1) & ~(sizeof(int) - 1) )

#define _crt_va_start(ap,v)  ( ap = (va_list)_ADDRESSOF(v) + _INTSIZEOF(v) )
#define _crt_va_arg(ap,t)    ( *(t *)((ap += _INTSIZEOF(t)) - _INTSIZEOF(t)) )
#define _crt_va_end(ap)      ( ap = (va_list)0 )

#define Test_va_start _crt_va_start 
#define Test_va_arg _crt_va_arg
#define Test_va_end _crt_va_end

#define ZEROPAD    1       
#define SIGN   2       
#define PLUS   4       
#define SPACE  8       
#define LEFT   16      
#define SPECIAL    32     
#define LARGE  64      

int _div(long* n,unsigned base);
static inline int isdigit(int ch);
static int skip_atoi(const char **s);
static char *Test_number(char *str, long num, int base, int size, int precision, int type);
int Test_vsprintf(char *buf, const char *fmt, va_list args);
int strnlen(const char * s, int precision);    
int sprintf(char *buf, const char *fmt, ...);


void fillbox(int color, int x0, int y0, int x1, int y1);
void myfillbox(int color, int x0, int y0, int x1, int y1);
void makefont16 (int color, int x, int y, short *font);
void print_gb2312(int color, int x, int y, unsigned char *str);

void delay(int count);
void *memcpy(void *dest, void *source, int count);

char string[] = "系统宕机！";
int kernel_main (unsigned int eax, unsigned int ebx) {
	fillbox(0x001e90ff, 0, 0, 799, 599);
	char buf[0x100], buf0[0x100];
	sprintf(buf, "eax = 0x%x ebx = 0x%x buf 的地址是 0x%x", eax, ebx, buf);
	print_gb2312(0xfffffff, 0, 0, buf);
	int i, j;
	for(i = 0; i < 400; i += 16) {
		fillbox(0xdddddddd, 16 + i, 16, 32 + i, 32);
		delay(0xffffff);
	}
	for(i = 0; i < 200; i += 16) {
		fillbox(0x88888888, 16 + i, 32, 32 + i, 48);
		delay(0xffffff);
	}
	for(j = 0; j < 208; j += 16) {
		for(i = 0; i < 150; i += 16) {
			fillbox(0xeeeeaaaa, 16 + i, 64 + j, 32 + i, 80 + j);
			delay(0xffffff);
		}
	}
	print_gb2312(0x00000000, 0, 568, (char *) memcpy(buf0, buf, 0x100));
	extern short font0[0x8000];
	makefont16(0x33ff7f00, 384, 224, font0);
	makefont16(0x33ff7f00, 400, 224, font0 + 16);
	makefont16(0x33ff7f00, 416, 224, font0 + 32);
	for(i = 0; i < 100; i += 16) {
		fillbox(0x22222222, 16 + i, 288, 32 + i, 304);
		delay(0xffffff);
	}
	return -1;
}





void fillbox(int color, int x0, int y0, int x1, int y1) {
	int *myfb = (int *)0xe0000000;
	int xsize = 800;
	int x, y;
	for (y = 0; y <= y1 - y0; y++) {
		for (x = 0; x <= x1 - x0; x++) {
			myfb[x0 + x + (y0 + y) * xsize] = color;
		}
	}
    return;
}


void print_ascii (int color, int x, int y, char *font) {
	int *myfb = (int *)0xe0000000;
	int xsize = 800;
	char d;
	int *p;
	int i;
	for (i = 0; i < 16; i++){
		p = myfb + (y + i) * xsize + x;
		d = font[i];
		if ((d & 0x80) != 0) {p[0] = color;}
		if ((d & 0x40) != 0) {p[1] = color;}
		if ((d & 0x20) != 0) {p[2] = color;}
		if ((d & 0x10) != 0) {p[3] = color;}
		if ((d & 0x08) != 0) {p[4] = color;}
		if ((d & 0x04) != 0) {p[5] = color;}
		if ((d & 0x02) != 0) {p[6] = color;}
		if ((d & 0x01) != 0) {p[7] = color;}
	}
	return;
}

void makefont16 (int color, int x, int y, short *font) {
	int *myfb = (int *)0xe0000000;
	int xsize = 800;
	short d;
	int *p;
	int i;
	for (i = 0; i < 16; i++){
		p = myfb + (y + i) * xsize + x;
		d = font[i];
		if ((d & 0x80) != 0) {p[0] = color;}
		if ((d & 0x40) != 0) {p[1] = color;}
		if ((d & 0x20) != 0) {p[2] = color;}
		if ((d & 0x10) != 0) {p[3] = color;}
		if ((d & 0x08) != 0) {p[4] = color;}
		if ((d & 0x04) != 0) {p[5] = color;}
		if ((d & 0x02) != 0) {p[6] = color;}
		if ((d & 0x01) != 0) {p[7] = color;}
		if ((d & 0x8000) != 0) {p[8] = color;}
		if ((d & 0x4000) != 0) {p[9] = color;}
		if ((d & 0x2000) != 0) {p[10] = color;}
		if ((d & 0x1000) != 0) {p[11] = color;}
		if ((d & 0x800) != 0) {p[12] = color;}
		if ((d & 0x400) != 0) {p[13] = color;}
		if ((d & 0x200) != 0) {p[14] = color;}
		if ((d & 0x100) != 0) {p[15] = color;}
	}
	return;
}

void print_gb2312(int color, int x, int y, unsigned char *str) {
	extern short font[0x8000];
	extern char myfont[0x1000];
	int i = 0, j = 0;
	unsigned char a, b;
	unsigned int offset;
	while (str[i] != 0) {
		if (str[i] < 0x80) {
			a = str[i];
			print_ascii (color, x + j, y, myfont + a * 16);
			if (str[i + 1] == 0)
				break;
			i++;
			j += 8;
		} else {	
			a = str[i] - 0xa0;
			b = str[i + 1] - 0xa0;
			offset = ((a - 1) * 94 + (b - 1)) * 16;
			makefont16 (color, x + j , y, font + offset);
			i += 2;
			j += 16;
		}
	}
	return;
}



int sprintf(char *buf, const char *fmt, ...)
{
    va_list args;
    int val = 1;
    Test_va_start(args, fmt);
	Test_vsprintf(buf, fmt, args);
    Test_va_end(args);
    return val;
}



int _div(long* n,unsigned base)
{
     int __res; 
         __res = ((unsigned long) *n) % (unsigned) base; 
         *n = ((unsigned long) *n) / (unsigned) base; 
         return __res;
}

#define do_div(n,base)   _div(&n,base)


static inline int isdigit(int ch)
{
    return (ch >= '0') && (ch <= '9');
}

static int skip_atoi(const char **s)
{
    int i = 0;

    while (isdigit(**s))
        i = i * 10 + *((*s)++) - '0';
    return i;
}

static char *Test_number(char *str, long num, int base, int size, int precision, int type)
{
    char c, sign, tmp[66];
    const char *digits = "0123456789abcdefghijklmnopqrstuvwxyz";
    int i;

    if (type & LARGE)
        digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    if (type & LEFT)
        type &= ~ZEROPAD;
    if (base < 2 || base > 36)
        return 0;
    c = (type & ZEROPAD) ? '0' : ' ';
    sign = 0;
    if (type & SIGN) {
        if (num < 0) {
            sign = '-';
            num = -num;
            size--;
        } else if (type & PLUS) {
            sign = '+';
            size--;
        } else if (type & SPACE) {
            sign = ' ';
            size--;
        }
    }
    if (type & SPECIAL) {
        if (base == 16)
            size -= 2;
        else if (base == 8)
            size--;
    }
    i = 0;
    if (num == 0)
    {
        tmp[i++] = '0';
    }
    else
    {
        while (num != 0)
        {
            tmp[i++] = digits[do_div(num, base)];
        }
    }

    if (i > precision)
        precision = i;
    size -= precision;
    if (!(type & (ZEROPAD + LEFT)))
        while (size-- > 0)
            *str++ = ' ';
    if (sign)
        *str++ = sign;
    if (type & SPECIAL) {
        if (base == 8)
            *str++ = '0';
        else if (base == 16) {
            *str++ = '0';
            *str++ = digits[33];
        }
    }
    if (!(type & LEFT))
        while (size-- > 0)
            *str++ = c;
    while (i < precision--)
        *str++ = '0';
    while (i-- > 0)
        *str++ = tmp[i];
    while (size-- > 0)
        *str++ = ' ';
    return str;
 }


int Test_vsprintf(char *buf, const char *fmt, va_list args)
{
    int len;
    unsigned long num;
    int i, base;
    char *str;
    const char *s;

    int flags;      

    int field_width;   
    int precision;    
    int qualifier;      

    for (str = buf; *fmt; ++fmt) {
        if (*fmt != '%') {
            *str++ = *fmt;
            continue;
        }


        flags = 0;
          repeat:
        ++fmt;      
        switch (*fmt) {
        case '-':
            flags |= LEFT;
            goto repeat;
        case '+':
            flags |= PLUS;
            goto repeat;
        case ' ':
            flags |= SPACE;
            goto repeat;
        case '#':
            flags |= SPECIAL;
            goto repeat;
        case '0':
            flags |= ZEROPAD;
            goto repeat;
        }


        field_width = -1;
        if (isdigit(*fmt))
            field_width = skip_atoi(&fmt);
        else if (*fmt == '*') {
            ++fmt;

            field_width = Test_va_arg(args, int);
            if (field_width < 0) {
                field_width = -field_width;
                flags |= LEFT;
            }
        }


        precision = -1;
        if (*fmt == '.') {
            ++fmt;
            if (isdigit(*fmt))
                precision = skip_atoi(&fmt);
            else if (*fmt == '*') {
                ++fmt;

                precision = Test_va_arg(args, int);
            }
            if (precision < 0)
                precision = 0;
        }


        qualifier = -1;
        if (*fmt == 'h' || *fmt == 'l' || *fmt == 'L') {
            qualifier = *fmt;
            ++fmt;
        }


        base = 10;

        switch (*fmt) {
        case 'c':
            if (!(flags & LEFT))
                while (--field_width > 0)
                    *str++ = ' ';
            *str++ = (unsigned char)Test_va_arg(args, int);
            while (--field_width > 0)
                *str++ = ' ';
            continue;

        case 's':
            s = Test_va_arg(args, char *);
            len = strnlen(s, precision);

            if (!(flags & LEFT))
                while (len < field_width--)
                    *str++ = ' ';
            for (i = 0; i < len; ++i)
                *str++ = *s++;
            while (len < field_width--)
                *str++ = ' ';
            continue;

        case 'p':
            if (field_width == -1) {
                field_width = 2 * sizeof(void *);
                flags |= ZEROPAD;
            }
            str = Test_number(str,
                     (unsigned long)Test_va_arg(args, void *), 16,
                     field_width, precision, flags);
            continue;

        case 'n':
            if (qualifier == 'l') {
                long *ip = Test_va_arg(args, long *);
                *ip = (str - buf);
            } else {
                int *ip = Test_va_arg(args, int *);
                *ip = (str - buf);
            }
            continue;

        case '%':
            *str++ = '%';
            continue;

        case 'o':
            base = 8;
            break;

        case 'X':
            flags |= LARGE;
        case 'x':
            base = 16;
            break;

        case 'd':
        case 'i':
            flags |= SIGN;
        case 'u':
            break;

        default:
            *str++ = '%';
            if (*fmt)
                *str++ = *fmt;
            else
                --fmt;
            continue;
        }
        if (qualifier == 'l')
            num = Test_va_arg(args, unsigned long);
        else if (qualifier == 'h') {
            num = (unsigned short)Test_va_arg(args, int);
            if (flags & SIGN)
                num = (short)num;
        } else if (flags & SIGN)
            num = Test_va_arg(args, int);
        else
            num = Test_va_arg(args, unsigned int);
        str = Test_number(str, num, base, field_width, precision, flags);
    }
    *str = '\0';
    return str - buf;
}        

int strnlen(const char * s, int precision) {
	int len = 0;
	while (*s++ != 0) {
		len++;
	}
	return len;
}



void *memcpy(void *dest, void *source, int count) {
	int i;
	for(i = 0; i < count; i++) {
		 *((char *)dest++) = *((char *)source++);
	}
	return dest;
}

boot.s

bits 32

section .text

global _start
extern _kernel_main, _print_gb2312, _string

_start:
	jmp mystart
align 8
header_start:
	dd 0xe85250d6
	dd 0x0
	dd header_end - header_start
	dd - (0xe85250d6 + 0x0 + (header_end - header_start))
	
add_tag_start:
	dw 0x2
	dw 0x0
	dd add_tag_end - add_tag_start
	dd header_start
	dd _start
	dd 0x0
	dd 0x0
add_tag_end:

entry_add_tag_start:
	dw 0x3
	dw 0x1
	dd entry_add_tag_end - entry_add_tag_start
	dd mystart
entry_add_tag_end:
align 8

framebuffer_tag_start:
	dw 0x5
	dw 0x1
	dd framebuffer_tag_end - framebuffer_tag_start
	dd 800
	dd 600
	dd 32
framebuffer_tag_end:
align 8

	dw 0x0
	dw 0x0
	dd 0x8
header_end:
align 8

mystart:
	mov esp, stack_start
	push 0
	popf
		
	push ebx
	push eax
	call _kernel_main
	add esp, 4 * 2

here:
	push _string
	push dword [y]
	push dword [x]
	push dword [color]
	call _print_gb2312
	add esp, 4 * 4
	hlt
	jmp here
	

y:	dd 584
x:	dd 0
color:
	dd 0x00ff0000


times 0x1000 db 0
align 0x1000
stack_start:


global _delay
_delay: ;void(int count);
	push ecx
	mov ecx, [esp + 4 * 2]
next:
	loop next
	pop ecx
	ret
	

Makefile

CC=gcc
LD=ld
OBJ = boot.o kernel.o myfont.o myfont1.o font0.o

all: kernel

.s.o:
	nasm -felf -o $@ $<
.c.o:
	$(CC) -o $@ -c $<

kernel: $(OBJ)
	$(LD) -Ttext 0x100000 -o $@ $^

default:	
	make all
	objcopy -I pe-i386 -O elf32-i386 kernel
	mount.cmd
 
run: 
	make default
	start virtualbox --startvm "C:\Users\Administrator\VirtualBox VMs\myos\myos.vbox" 
clean:
	del boot.o
	del kernel.o
	del kernel