Day04

Author Avatar
CCDV2 3月 10, 2019

今天主要讲了C语言接近底层的指针用法，以及有关显卡设置的一些方法。

一些问题与感想

C语言指针的底层用法

我们知道，汇编里有 BYTE、WORD、DWORD，可以进行对应字节数的地址操作。相应的，C语言中我们可以使用char、short、int类型的指针来达到相同的效果（不得不说这种直接操作内存想法第一次见，毕竟以前也用不到）。

书里提到的并不完整

例如有时候，书中只说明了c文件的改动，但是发现居然多了个函数声明，却没有实现。这时候应该就要想到naskfunc可能也改动了，赶紧去看看别的文件吧。

二维数组 VS 一维数组

在书中我们可以看到，在设置屏幕（一个二维坐标）的时候，用的是一个一维数组+计算偏移量的方法。那么哪种写法更好呢？如果说从可读性、可移植性、传参的角度来讲，一维数组应该是2:1胜出。

进入正题

用C语言实现内存写入

harib01a

写一个对应的汇编函数，实现8位内存写入，当然前面global里也要写。

_write_mem8: ; void write_mem8(int addr, int data);
    MOV ECX, [ESP + 4] ; [ESP + 4]中存放了地址，将其读入ECX
    MOV AL, [ESP + 8] ; [ESP + 8]中存放了数据， 将其读入AL
    MOV [ECX], AL
    RET

在这里我们看到了传参的写法：传入的时候，从右到左将参数压入栈顶（这部分编译器帮我们写的），取出的时候从左到右将参数取出。
c语言部分

void io_hlt(void);
void write_mem8(int addr, int data);

void HariMain(void)
{
    int i;
    /*把VRAM全都写入了15， 颜色为白*/
    for(i = 0xa0000; i <= 0xaffff; ++i)
    {
        write_mem8(i, 15); /*MOV BYTE [i], 15*/
    }
    for(;;)
    {
        io_hlt(); /* 执行naskfunc.nas的_io_hlt */
    }
}

对于我们来说应该不难理解。现在出来的结果是显示屏为白色。

条纹图案

harib01b

我们在vram里写点别的，弄个条纹图案

void io_hlt(void);
void write_mem8(int addr, int data);

void HariMain(void)
{
    int i;
    /*把VRAM 形成条纹图案*/
    for(i = 0xa0000; i <= 0xaffff; ++i)
    {
        write_mem8(i, i & 0x0f); /*MOV BYTE [i], 15*/
    }
    for(;;)
    {
        io_hlt(); /* 执行naskfunc.nas的_io_hlt */
    }
}

进行与运算后，地址对应的颜色每16位就会重复一次，对应到屏幕上就是条纹图案了。

挑战指针

harib01c

接下来是指针比较高级的用法，用指针来直接改写内存，开头已经提到过了，还是挺值得琢磨一下的。

void io_hlt(void);
void write_mem8(int addr, int data);

void HariMain(void)
{
    int i;
    char *p;
    /*把VRAM 形成条纹图案*/
    for(i = 0xa0000; i <= 0xaffff; ++i)
    {
        p = (char *)i; /*代入地址，很高级的写法啊*/
        *p = i & 0x0f;
    }
    for(;;)
    {
        io_hlt(); /* 执行naskfunc.nas的_io_hlt */
    }
}

当然，为了编译器不发出太多警告，还是强制转换一下指针类型比较好。
对于C语言指针的语法，这里就不说了。

指针的应用

harib01d
harib01e

其实就是数组与指针的转化。

p = (char *)0xa0000;

for(i = 0; i <= 0xffff; ++i)
{
    p[i] = i & 0x0f; /*与*(p + i)等价*/
}

当然，也要明白数组写法不仅仅是数组，理解为地址+偏移量就可以了。

色号设定

harib01f

这里相当于建立了颜色的索引表，也就是调色板(palette)。我们可以指定256种颜色来使用，每种颜色可对应一个24位的8位RGB颜色。
接下来往.c里添加初始化调色板，以及设置调色板等操作。

void io_hlt(void);
void io_cli(void);
void io_out8(int port, int data);
int io_load_eflags(void);
void io_store_eflags(int eflags);

void init_palette(void);
void set_palette(int start, int end, unsigned char *rgb);


void HariMain(void)
{
    int i;
    char *p;

    init_palette();

    p = (char *)0xa0000;

    for(i = 0; i <= 0xffff; ++i)
    {
        p[i] = i & 0x0f;
    }
    for(;;)
    {
        io_hlt(); /* 执行naskfunc.nas的_io_hlt */
    }
}

void init_palette(void)
{
    static unsigned char table_rgb[16 * 3] =
    {
        0x00, 0x00, 0x00, /*0:黑*/
        0xff, 0x00, 0x00, /*1:亮红*/
        0x00, 0xff, 0x00, /*2:亮绿*/
        0xff, 0xff, 0x00, /*3:亮黄*/
        0x00, 0x00, 0xff, /*4:亮蓝*/
        0xff, 0x00, 0xff, /*5:亮紫*/
        0x00, 0xff, 0xff, /*6:浅亮蓝*/
        0xff, 0xff, 0xff, /*7:白*/
        0xc6, 0xc6, 0xc6, /*8:亮灰*/
        0x84, 0x00, 0x00, /*9:暗红*/
        0x00, 0x84, 0x00, /*10:暗绿*/
        0x84, 0x84, 0x00, /*11:暗黄*/
        0x00, 0x00, 0x84, /*12:暗青*/
        0x84, 0x00, 0x84, /*13:暗紫*/
        0x00, 0x84, 0x84, /*14:浅暗蓝*/
        0x84, 0x84, 0x84  /*15:暗灰*/
    };
    set_palette(0, 15, table_rgb);
    return;
}

void set_palette(int start, int end, unsigned char *rgb)
{
    int i, eflags;
    eflags = io_load_eflags(); /*记录中断许可标志的值*/
    io_cli(); /*将中断许可的标志置为0， 禁止中断*/
    io_out8(0x03c8, start);
    for(i = start; i <= end; ++i)
    {
        io_out8(0x03c9, rgb[0] / 4); /*右移两位，最高两位为0*/
        io_out8(0x03c9, rgb[1] / 4);
        io_out8(0x03c9, rgb[2] / 4);
        rgb += 3;
    }
    io_store_eflags(eflags); /*复原中断许可标志*/
    return;
}

值得注意的几点：

  1. unsigned类型很重要，不然解释成负数，或者右移补符号位，都不是我们想要的结果
  2. 作者帮我们写好了中断相关的函数，在设置颜色的时候要关中断
  3. EFLAGS寄存器里存储了各种flag（顾名思义），系统在中断的时候要检查一下相应位是0还是1。

汇编语言部分

; naskfunc
; TAB=4

[FORMAT "WCOFF"]                ; 制作目标文件的格式
[INSTRSET "i486p"]                ; 使用到486为止的命令
[BITS 32]                        ; 制作32位模式的机器语言
[FILE "naskfunc.nas"]            ; 源程序文件名

        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        EAX,[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        ; 指PUSH EFLAGS
        POP        EAX
        RET

_io_store_eflags:    ; void io_store_eflags(int eflags);
        MOV        EAX,[ESP+4]
        PUSH    EAX
        POPFD        ; 指POP EFLAGS
        RET

这里有一些IO指令：IN, OUT，还有对标志位操作的PUSHFD和POPFD。
另外，EAX的值在RET时会当作返回值。
现在的结果是条纹颜色会不一样。

绘制矩形

harib01g

现在我们可以通过填充像素，来画点、画线、画矩形。接下来就画个矩形吧。
自己写的和书上的不太一样，用enum代替了define，省些笔墨。

void io_hlt(void);
void io_cli(void);
void io_out8(int port, int data);
int io_load_eflags(void);
void io_store_eflags(int eflags);

void init_palette(void);
void set_palette(int start, int end, unsigned char *rgb);

void boxfill8(unsigned char *vram, int xsize, unsigned char c, int x0, int y0, int x1, int y1);

enum COL
{
    COL8_000000,
    COL8_FF0000,
    COL8_00FF00,
    COL8_FFFF00,
    COL8_0000FF,
    COL8_FF00FF,
    COL8_00FFFF,
    COL8_FFFFFF,
    COL8_C6C6C6,
    COL8_840000,
    COL8_008400,
    COL8_848400,
    COL8_000084,
    COL8_840084,
    COL8_008484,
    COL8_848484
};

void HariMain(void)
{
    char *p;

    init_palette();

    p = (char *)0xa0000;

    boxfill8(p, 320, COL8_FF0000, 20, 20, 120, 120);
    boxfill8(p, 320, COL8_00FF00, 70, 50, 170, 150);
    boxfill8(p, 320, COL8_0000FF, 120, 80, 220, 180);

    for(;;)
    {
        io_hlt(); /* 执行naskfunc.nas的_io_hlt */
    }
}

void init_palette(void)
{
    static unsigned char table_rgb[16 * 3] =
    {
        0x00, 0x00, 0x00, /*0:黑*/
        0xff, 0x00, 0x00, /*1:亮红*/
        0x00, 0xff, 0x00, /*2:亮绿*/
        0xff, 0xff, 0x00, /*3:亮黄*/
        0x00, 0x00, 0xff, /*4:亮蓝*/
        0xff, 0x00, 0xff, /*5:亮紫*/
        0x00, 0xff, 0xff, /*6:浅亮蓝*/
        0xff, 0xff, 0xff, /*7:白*/
        0xc6, 0xc6, 0xc6, /*8:亮灰*/
        0x84, 0x00, 0x00, /*9:暗红*/
        0x00, 0x84, 0x00, /*10:暗绿*/
        0x84, 0x84, 0x00, /*11:暗黄*/
        0x00, 0x00, 0x84, /*12:暗青*/
        0x84, 0x00, 0x84, /*13:暗紫*/
        0x00, 0x84, 0x84, /*14:浅暗蓝*/
        0x84, 0x84, 0x84  /*15:暗灰*/
    };
    set_palette(0, 15, table_rgb);
    return;
}

void set_palette(int start, int end, unsigned char *rgb)
{
    int i, eflags;
    eflags = io_load_eflags(); /*记录中断许可标志的值*/
    io_cli(); /*将中断许可的标志置为0， 禁止中断*/
    io_out8(0x03c8, start);
    for(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); /*复原中断许可标志*/
    return;
}

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

这上面用一个一维数组来代替了二维数组，其实计算好相对的偏移量，这么写也完全没有问题。
那可能会说，为什么不用二维数组呢？因为二维数组必须要固定第二维，否则编译器就不知道该如何偏移。比起这样，不如我们在传参时多传一点，自己计算个偏移量更加灵活。

今天的成果

harib01h

现在通过画矩形，来画一个初见雏形的操作系统。
添加部分：

void HariMain(void)
{
    char *vram = (char *)0xa0000;
    int xsize = 320, ysize = 200;

    init_palette();


    boxfill8(vram, xsize, COL8_008484,  0,         0,          xsize -  1, ysize - 29);
    boxfill8(vram, xsize, COL8_C6C6C6,  0,         ysize - 28, xsize -  1, ysize - 28);
    boxfill8(vram, xsize, COL8_FFFFFF,  0,         ysize - 27, xsize -  1, ysize - 27);
    boxfill8(vram, xsize, COL8_C6C6C6,  0,         ysize - 26, xsize -  1, ysize -  1);

    boxfill8(vram, xsize, COL8_FFFFFF,  3,         ysize - 24, 59,         ysize - 24);
    boxfill8(vram, xsize, COL8_FFFFFF,  2,         ysize - 24,  2,         ysize -  4);
    boxfill8(vram, xsize, COL8_848484,  3,         ysize -  4, 59,         ysize -  4);
    boxfill8(vram, xsize, COL8_848484, 59,         ysize - 23, 59,         ysize -  5);
    boxfill8(vram, xsize, COL8_000000,  2,         ysize -  3, 59,         ysize -  3);
    boxfill8(vram, xsize, COL8_000000, 60,         ysize - 24, 60,         ysize -  3);

    boxfill8(vram, xsize, COL8_848484, xsize - 47, ysize - 24, xsize -  4, ysize - 24);
    boxfill8(vram, xsize, COL8_848484, xsize - 47, ysize - 23, xsize - 47, ysize -  4);
    boxfill8(vram, xsize, COL8_FFFFFF, xsize - 47, ysize -  3, xsize -  4, ysize -  3);
    boxfill8(vram, xsize, COL8_FFFFFF, xsize -  3, ysize - 24, xsize -  3, ysize -  3);

    for(;;)
    {
        io_hlt(); /* 执行naskfunc.nas的_io_hlt */
    }
}

最终效果
final
所以说渐变其实都是一个个矩形叠加起来的。。
今天任务总算完成了，明天再说。