本章主要是针对命令行窗口的一些优化工作，主要包括提高窗口的移动速度、增加更多的命令行窗口以及关闭命令行窗口（之前介绍的是关闭应用程序窗口）。
一 提高窗口移动速度
【优化1】：优化 sheet_refreshmap 函数以提升窗口的移动速度。优化方案是判断将对透明图层的判断放到循环嵌套的外面，可以减小判断的执行次数。
if (sht->col_inv == -1) { /*从此开始*/
/*无透明色图层专用的高速版*/
for (by = by0; by < by1; by++) {
vy = sht->vy0 + by;
for (bx = bx0; bx < bx1; bx++) {
vx = sht->vx0 + bx;
map[vy * ctl->xsize + vx] = sid;
}
}
} else {
/*有透明色图层用的普通版*/
for (by = by0; by < by1; by++) {
vy = sht->vy0 + by;
for (bx = bx0; bx < bx1; bx++) {
vx = sht->vx0 + bx;
if (buf[by * sht->bxsize + bx] != sht->col_inv) {
map[vy * ctl->xsize + vx] = sid;
}
}
}
}【优化2】：针对上面 sheet_refreshmap 中的一句进行优化，该命令的功能是向内存中某个地址写入sid的值，它也位于for循环中，被反复执行：
map[vy * ctl->xsize + vx] = sid;在汇编语言中，如果我们用16 位寄存器代替8位寄存器来执行MOV指令的话，相邻的地址中也会同时写入数据，而如果用32位寄存器，仅1条指令就可以同时向相邻的4个地址写入值了。更重要的是，即便是同时写入4个字节的值，只要指定地址是4的整数倍，指令的执行速度就和1个字节的MOV是相同的。优化如下：
if ((sht->vx0 & 3) == 0 && (bx0 & 3) == 0 && (bx1 & 3) == 0) {
/*无透明色图层专用的高速版（4字节型整除型）*/
bx1 = (bx1 - bx0) / 4; /* MOV次数*/
sid4 = sid | sid << 8 | sid << 16 | sid << 24;
for (by = by0; by < by1; by++) {
vy = sht->vy0 + by;
vx = sht->vx0 + bx0;
p = (int *) &map[vy * ctl->xsize + vx];
for (bx = 0; bx < bx1; bx++) {
p[bx] = sid4;
}
}
}这边用 sid4 代替 sid ，一次性对四个内存地址写入相同的颜色数据，相当于将执行速度提升了4倍。
为了将优化明显的发挥出来，我们需要使窗口在x方向上的大小为4的倍数，而且窗口的x坐标也要为4的倍数对于窗口坐标，我们需要做AND运算来取整，使打开窗口时的显示位置为4的倍数。与此同时，当用鼠标拖动窗口时如果目的地坐标不是4的倍数，我们这次的修改也就没有效果了，为了避免这种情况，我们必须保证目的地坐标为4的倍数才行：
sheet_slide(sht, ((shtctl->xsize - esi) / 2) & ~3, (shtctl->ysize - edi) / 2);/* bootpack.c */
// ...
int j, x, y, mmx = -1, mmy = -1, mmx2 = 0;
// ...
if (3 <= x && x < sht->bxsize - 3 && 3 <= y && y < 21) {
mmx = mx; /*进入窗口移动模式*/
mmy = my;
mmx2 = sht->vx0;
}
// ...
/*如果处于窗口移动模式*/
x = mx - mmx; /*计算鼠标的移动距离*/
y = my - mmy;
sheet_slide(sht, (mmx2 + x + 2) & ~3, sht->vy0 + y);
mmy = my;【优化3】：一次性写入4个字节的办法可以有效地提高速度，那么该方法也可以应用于诸如 sheet_refreshsub 函数中，窗口移动的时候也调用了这个函数。
void sheet_refreshsub(struct SHTCTL *ctl, int vx0, int vy0, int vx1, int vy1, int h0, int h1)
{
int h, bx, by, vx, vy, bx0, by0, bx1, by1, bx2, sid4, i, i1, *p, *q, *r;/* 这里 */
/* 中略 */
for (h = h0; h <= h1; h++) {
/* 中略 */
if ((sht->vx0 & 3) == 0) {
/* 4字节型 */
i = (bx0 + 3) / 4; /* bx0除以4（小数进位） */
i1 = bx1 / 4; /* bx1除以4（小数舍去） */
i1 = i1 - i;
sid4 = sid | sid << 8 | sid << 16 | sid << 24;
for (by = by0; by < by1; by++) {
vy = sht->vy0 + by;
for (bx = bx0; bx < bx1 && (bx & 3) != 0; bx++) { /* 前面被4除多余的部分逐个字节写入 */
vx = sht->vx0 + bx;
if (map[vy * ctl->xsize + vx] == sid) {
vram[vy * ctl->xsize + vx] = buf[by * sht->bxsize + bx];
}
}
vx = sht->vx0 + bx;
p = (int *) &map[vy * ctl->xsize + vx];
q = (int *) &vram[vy * ctl->xsize + vx];
r = (int *) &buf[by * sht->bxsize + bx];
for (i = 0; i < i1; i++) { /* 4的倍数部分 */
if (p[i] == sid4) {
q[i] = r[i]; /* 估计大多数回事这种情况，因此速度变快 */
} else {
bx2 = bx + i * 4;
vx = sht->vx0 + bx2;
if (map[vy * ctl->xsize + vx + 0] == sid) {
vram[vy * ctl->xsize + vx + 0] = buf[by * sht->bxsize + bx2 + 0];
}
if (map[vy * ctl->xsize + vx + 1] == sid) {
vram[vy * ctl->xsize + vx + 1] = buf[by * sht->bxsize + bx2 + 1];
}
if (map[vy * ctl->xsize + vx + 2] == sid) {
vram[vy * ctl->xsize + vx + 2] = buf[by * sht->bxsize + bx2 + 2];
}
if (map[vy * ctl->xsize + vx + 3] == sid) {
vram[vy * ctl->xsize + vx + 3] = buf[by * sht->bxsize + bx2 + 3];
}
}
}
for (bx += i1 * 4; bx < bx1; bx++) { /* 后面被4除多余的部分逐个字节写入 */
vx = sht->vx0 + bx;
if (map[vy * ctl->xsize + vx] == sid) {
vram[vy * ctl->xsize + vx] = buf[by * sht->bxsize + bx];
}
}
}
} else {
/* 1字节型 */
for (by = by0; by < by1; by++) {
vy = sht->vy0 + by;
for (bx = bx0; bx < bx1; bx++) {
vx = sht->vx0 + bx;
if (map[vy * ctl->xsize + vx] == sid) {
vram[vy * ctl->xsize + vx] = buf[by * sht->bxsize + bx];
}
}
}
}
}
return;
}【优化4】：明明已经放开了鼠标键，窗口却还在挪动，这是因为绘图操作非常浪费时间，导致系统来不及处理 FIFO 中鼠标移动数据，为此，我们可以接收到鼠标移动数据后不立即经行绘图操作，而是在 FIFO 为空时再进行。
if (fifo32_status(&fifo) == 0) {
/* FIFO为空，当存在搁置的绘图操作时立即执行*/
if (new_mx >= 0) {
io_sti();
sheet_slide(sht_mouse, new_mx, new_my);
new_mx = -1;
} else if (new_wx != 0x7fffffff) {
io_sti();
sheet_slide(sht, new_wx, new_wy);
new_wx = 0x7fffffff;
} else {
task_sleep(task_a);
io_sti();
}
}
// ...
// sheet_slide（sht_mouse, mx, my）
new_mx = mx;
new_my = my;
/*如果处于窗口移动模式*/
x = mx - mmx; /*计算鼠标的移动距离*/
y = my - mmy;
sheet_slide(sht, (mmx2 + x + 2) & ~3, sht->vy0 + y);
mmy = my;
// 没有按下左键就是一般的模式 我们并不真的移动鼠标图层的位置，而是将移动后的坐标暂且保存起来，当FIFO为空时，再执行sheet_slide（sht_mouse, new_mx, new_my）。
当放开鼠标左键退出移动模式的时候，即使 FIFO 不为空也要立即更新窗口位置，这是因为用户可能马上会去移动别的窗口，那样的话sht变量的值就会发生变化，因此我们必须在sht变量的值改变之前将当前窗口移动到指定的位置。
二 增加更多的命令行窗口
【优化1】：目前启动的时候就出现两个命令行窗口，这边优化一下，使得启动的时候就一个，然后按 Shift+F2 增加新的命令行窗口。
为此，先封装一个打开新命令行窗口的函数 open_console ，这其中包括分配初始内存、图层设置、任务栈设置以及FIFO缓冲区初始化等内容：
struct SHEET *open_console(struct SHTCTL *shtctl, unsigned int memtotal)
{
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
struct SHEET *sht = sheet_alloc(shtctl);
unsigned char *buf = (unsigned char *) memman_alloc_4k(memman, 256 * 165);
struct TASK *task = task_alloc();
int *cons_fifo = (int *) memman_alloc_4k(memman, 128 * 4);
sheet_setbuf(sht, buf, 256, 165, -1); /* 无透明色 */
make_window8(buf, 256, 165, "console", 0);
make_textbox8(sht, 8, 28, 240, 128, COL8_000000);
task->tss.esp = memman_alloc_4k(memman, 64 * 1024) + 64 * 1024 - 12;
task->tss.eip = (int) &console_task;
task->tss.es = 1 * 8;
task->tss.cs = 2 * 8;
task->tss.ss = 1 * 8;
task->tss.ds = 1 * 8;
task->tss.fs = 1 * 8;
task->tss.gs = 1 * 8;
*((int *) (task->tss.esp + 4)) = (int) sht;
*((int *) (task->tss.esp + 8)) = memtotal;
task_run(task, 2, 2); /* level=2, priority=2 */
sht->task = task;
sht->flags |= 0x20; /* 有光标 */
fifo32_init(&task->fifo, 128, cons_fifo, task);
return sht;
}而后在 HariMain 中点击 Shift+F2 的时候调用：
/* sht_cons */
sht_cons[0] = open_console(shtctl, memtotal);
sht_cons[1] = 0; /*未打开状态*/
/* 中略 */
sheet_slide(sht_back, 0, 0);
sheet_slide(sht_cons[0], 32, 4);
sheet_slide(sht_mouse, mx, my);
sheet_updown(sht_back, 0);
sheet_updown(sht_cons[0], 1);
sheet_updown(sht_mouse, 2); /*从此开始*/
key_win = sht_cons[0];
keywin_on(key_win);
/* 中略 */
if (i == 256 + 0x3c && key_shift != 0 && sht_cons[1] == 0) { /* Shift+F2 */
sht_cons[1] = open_console(shtctl, memtotal); /* 调用open_console */
sheet_slide(sht_cons[1], 32, 4);
sheet_updown(sht_cons[1], shtctl->top);
/*自动将输入焦点切换到新打开的命令行窗口（这样比较方便吧？） */
keywin_off(key_win);
key_win = sht_cons[1];
keywin_on(key_win);
}这样便可以实现启动时就一个命令行窗口，然后后面的命令行窗口通过 Shift+F2 调用。
【优化2】：为了增加更多的命令行窗口，干脆把之前的 sht_cons[] 数组删除了（之前的程序中我们是先向sht_cons[]赋值，然后再由 sht_cons[]赋值给key_win），改成直接向key_win赋值。
struct SHEET *sht_back, *sht_mouse; /* 这边删去 sht_cons[2] */
/* sht_cons */
key_win = open_console(shtctl, memtotal);
sheet_slide(sht_back, 0, 0);
sheet_slide(key_win, 32, 4); /* sht_cons[0]---->key_win */
sheet_slide(sht_mouse, mx, my);
sheet_updown(sht_back, 0);
sheet_updown(key_win, 1); /* sht_cons[0]---->key_win */
sheet_updown(sht_mouse, 2);
keywin_on(key_win);
if (i == 256 + 0x3c && key_shift != 0) { /* Shift+F2 */
if (key_win != 0) {
keywin_off(key_win);
}
key_win = open_console(shtctl, memtotal);
sheet_slide(key_win, 32, 4); /* sht_cons[1]---->key_win */
sheet_updown(key_win, shtctl->top); /* sht_cons[1]---->key_win */
keywin_on(key_win);
}这样，命令行窗口便不再有数量的限制，只要内存足够，想开多少个开多少个（这样就实现了同时开启多个应用程序的功能，不过美中不足的是，每多开一个应用程序，就有一个与之对应的命令行窗口，这样很不爽，后面小节会改进）。
三 关闭命令行窗口
【关闭方式1】：之前完成了关闭应用程序窗口的操作，现在考虑增加一个 exit 命令来关闭命令行窗口。
关闭命令行窗口的时候，需要将该窗口占用的内存释放，同时还需要释放窗口的图层和任务栈。但是问题来了，之前把 sht_cons[] 数组取消掉了，直接用 key_win 代替了，但这个 key_win 是变化的，也就是说创建任务时我们为命令行窗口准备的栈地址没有得到保存，导致这个时候需要关闭指定窗口，却找不到它的栈地址。所以，我们需要在TASK结构中添加一个 cons_stack 成员，用来保存栈的地址：
/* bootpack.h */
struct TASK {
int sel, flags; /* sel为GDT编号*/
int level, priority;
struct FIFO32 fifo;
struct TSS32 tss;
struct CONSOLE *cons;
int ds_base, cons_stack; /*这里！*/
};
/* bootpack.c */
struct SHEET *open_console(struct SHTCTL *shtctl, unsigned int memtotal)
{
/* 中略 */
task->cons_stack = memman_alloc_4k(memman, 64 * 1024);
task->tss.esp = task->cons_stack + 64 * 1024 - 12;
/* 中略 */
}接下来封装关闭图层和关闭任务的函数：
void close_constask(struct TASK *task)
{
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
task_sleep(task);
memman_free_4k(memman, task->cons_stack, 64 * 1024);
memman_free_4k(memman, (int) task->fifo.buf, 128 * 4);
task->flags = 0; /*用来替代task_free(task); */
return;
}
void close_console(struct SHEET *sht)
{
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
struct TASK *task = sht->task;
memman_free_4k(memman, (int) sht->buf, 256 * 165);
sheet_free(sht);
close_constask(task);
return;
} 我们将创建 console 中的创建任务的过程解耦， 在创建图层结束之后调用创建任务，在关闭图层之后调用 close_constask。在close_constask中，一开始我们先让任务进入休眠状态，这是为了将任务从等待切换列表中安全地剥离出来，因为这样一来就绝对不会切换到该任务，我们就可以安全地释放栈和FIFO缓冲区了。当全部内存空间都释放完毕之后，为了task_alloc下次能够重新利用这些内存空间，我们还需要将flags置为0。
下面来编写 exit 命令：
void cmd_exit(struct CONSOLE *cons, int *fat)
{
struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
struct TASK *task = task_now();
struct SHTCTL *shtctl = (struct SHTCTL *) *((int *) 0x0fe4);
struct FIFO32 *fifo = (struct FIFO32 *) *((int *) 0x0fec);
timer_cancel(cons->timer);
memman_free_4k(memman, (int) fat, 4 * 2880);
io_cli();
fifo32_put(fifo, cons->sht - shtctl->sheets0 + 768); /* 768〜1023 */
io_sti();
for (;;) {
task_sleep(task);
}
}如果在 cmd_exit 中调用 close_console 的话，就相当于 close_constask 中的 task_sleep 对自己这个任务本身执行休眠，那么之后的程序就都无法继续执行下去了。为此，我们需要让 task_a 来执行，此处的 task_a 负责的是处理鼠标指针的移动、将键盘输入的数据分配给各命令行窗口等工作。我们使用从命令行窗口向 task_a 发送发送一个数据将其唤醒，帮忙关闭窗口任务。
接下来就是休眠就可以了，这边需要注意，结束任务不能由命令行任务自己来完成，需要命令行窗口任务像task_a任务发送一个数据，请task_a任务帮忙关闭自己才行（如果任务对自己执行休眠，那么之后的程序都无法继续执行下去了）：
/* bootpack.c */
// ...
*((int *) 0x0fec) = (int) &fifo;
// ...
if (key_win->flags == 0) { /*输入窗口被关闭*/
if (shtctl->top == 1) { /*当画面上只剩鼠标和背景时*/
key_win = 0;
} else {
key_win = shtctl->sheets[shtctl->top - 1];
keywin_on(key_win);
}
}
// ...
if (s[0] != 0 && key_win != 0) { /*一般字符、退格键、回车键*/
fifo32_put(&key_win->task->fifo, s[0] + 256);
}
// 加上对 `key_win` 的判断
// ...
else if (768 <= i && i <= 1023) { /*命令行窗口关闭处理*/
close_console(shtctl->sheets0 + (i - 768));
}【关闭方式2】：除了exit，还需要鼠标点击“X”关闭。
实现方法是，当鼠标点击“X”时，向命令行窗口任务发送4这个数据，命令行窗口接收到这个数据之后则开始执行exit命令的程序。
点击“X”发送4：
/* bootpack.c */
else { /* 命令行窗口 */
task = sht->task;
io_cli();
fifo32_put(&task->fifo, 4);
io_sti();
}命令行任务收到4，执行exit退出：
/* console.c */
if (i == 4) { /*点击命令行窗口的“×”按钮*/
cmd_exit(&cons, fat);
}综上，就可以通过exit命令或者鼠标点击“X”的方式实现关闭命令行窗口任务。
四 新增两个执行应用程序命令（start、ncst）
【1】新增命令 start 用来实现新建一个命令行窗口，并执行start之后的应用程序。
/* console.c */
void cmd_start(struct CONSOLE *cons, char *cmdline, int memtotal)
{
struct SHTCTL *shtctl = (struct SHTCTL *) *((int *) 0x0fe4);
struct SHEET *sht = open_console(shtctl, memtotal);
struct FIFO32 *fifo = &sht->task->fifo;
int i;
sheet_slide(sht, 32, 4);
sheet_updown(sht, shtctl->top);
/*将命令行输入的字符串逐字复制到新的命令行窗口中*/
for (i = 6; cmdline[i] != 0; i++) {
fifo32_put(fifo, cmdline[i] + 256);
}
fifo32_put(fifo, 10 + 256); /*回车键*/
cons_newline(cons);
return;
}直接执行 color2 与执行 start color2 的效果对比如下：
【2】新增命令 ncst用来实现不打开一个新的命令行窗口，执行ncst之后的应用程序。
/* console.c */
void cmd_ncst(struct CONSOLE *cons, char *cmdline, int memtotal)
{
struct TASK *task = open_constask(0, memtotal); /* 与start命令的区别 */
struct FIFO32 *fifo = &task->fifo;
int i;
/*将命令行输入的字符串逐字复制到新的命令行窗口中*/
for (i = 5; cmdline[i] != 0; i++) {
fifo32_put(fifo, cmdline[i] + 256);
}
fifo32_put(fifo, 10 + 256); /*回车键*/
cons_newline(cons);
return;
}当cons—>sht为0时，要禁用命令行窗口的字符显示等所有操作，因此我们需要修改与其相关的函数。接下来修改 console_task 当不显示命令行窗口时，禁用一些不必要的处理，并且当命令执行完毕时，立即结束命令行窗口任务。需要使其在命令执行完毕时自动终止任务。具体表现在根据 sheet == 0 来判断是否是命令行窗口，如果不是则不会获得光标定时器和在 cons_runcmd 之后自动关闭和不会显示光标。
cmd_exit 也要添加用于无命令行窗口情况下的任务结束处理：
fifo32_put(fifo, task - taskctl->tasks0 + 1024); /*1024～2023*/ 有命令行窗口时，我们可以通过图层的地址告诉task_a需要结束哪个任务。而无命令行窗口的情况下，这种方法就用不了了，因此在这里我们将TASK结构的地址告诉task_a。
最后来修改 HariMain 添加一点代码即可：
else if (1024 <= i && i <= 2023) {
close_constask(taskctl->tasks0 + (i - 1024));
}直接执行 color2 与执行 ncst color2 的效果对比如下：
这样就可以曲线救国实现一个命令行运行多个应用程序的效果了。最后，还出现一个BUG，就是这边的应用程序窗口无法通过之前的 Shift+F1 或者“X”关闭，这个问题下一章解决吧。
3027
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
