1　程序整理（harib17a）

大家早上好，今天我们继续努力哦。昨天我们已经实现了应用程序的运行，今天我们来实现由应用程序对操作系统功能的调用（即API，也叫系统调用）。

为什么这样的功能称为“系统调用”（system call）呢？因为它是由应用程序来调用（操作）系统中的功能来完成某种操作，这个名字很直白吧。

“API”这个名字就稍微复杂些，是“application program interface”的缩写，即“应用程序（与系统之间的）接口”的意思。

请大家把这两个名字记住哦，考试题目中会有的哦……开玩笑啦，这些其实用不着记啦。有记这些单词的工夫，还不如多享受一下制作操作系统的乐趣呢。

以后，在本书中会更多地使用“API”这个名字，理由很简单，因为它比较短嘛（笑）！

这值得纪念的第一次，我们就来做个在命令行窗口中显示字符的API吧。BIOS中也有这个功能哦，如果忘了的话请重新看看第二天的内容。怎么样，找到了吧？无论什么样的操作系统，都会有功能类似的API，这可以说是必需的。

■■■■■

下面来改造一下我们操作系统，让它可以使用API吧……等等，现在这程序是怎么回事！尤其是console_task，简直太不像样了。看着如此混乱的程序代码，真是提不起任何干劲来进行改造，我们还是先把程序整理一下吧。

由于只是改变了程序的写法，并没有改变程序处理的内容，因此这里就不讲解了。原本很长的console_task，从249行改到了85行，哦耶！不过由于创建了很多函数，整体的行数反而比原来多了，叹。

本次的console.c节选

  1. struct CONSOLE {
  2.     struct SHEET *sht;
  3.     int cur_x, cur_y, cur_c;
  4. };
  6. void console_task(struct SHEET *sheet, unsigned int memtotal)
  7. {
  8.     struct TIMER *timer;
  9.     struct TASK *task = task_now();
  10.     struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
  11.     int i, fifobuf[128], *fat = (int *) memman_alloc_4k(memman, 4 * 2880);
  12.     struct CONSOLE cons;
  13.     char cmdline[30];
  14.     cons.sht = sheet;
  15.     cons.cur_x =  8;
  16.     cons.cur_y = 28;
  17.     cons.cur_c = -1;
  19.     fifo32_init(&task->fifo, 128, fifobuf, task);
  20.     timer = timer_alloc();
  21.     timer_init(timer, &task->fifo, 1);
  22.     timer_settime(timer, 50);
  23.     file_readfat(fat, (unsigned char *) (ADR_DISKIMG + 0x000200));
  25.     /*显示提示符*/
  26.     cons_putchar(&cons, '>', 1);
  28.     for (;;) {
  29.         io_cli();
  30.         if (fifo32_status(&task->fifo) == 0) {
  31.             task_sleep(task);
  32.             io_sti();
  33.         } else {
  34.             i = fifo32_get(&task->fifo);
  35.             io_sti();
  36.             if (i <= 1) { /*光标用定时器*/
  37.                 if (i != 0) {
  38.                     timer_init(timer, &task->fifo, 0); /*下次置0 */
  39.                     if (cons.cur_c >= 0) {
  40.                         cons.cur_c = COL8_FFFFFF;
  41.                     }
  43.                 } else {
  44.                     timer_init(timer, &task->fifo, 1); /*下次置1 */
  46.                     if (cons.cur_c >= 0) {
  47.                         cons.cur_c = COL8_000000;
  48.                     }
  49.                 }
  50.                 timer_settime(timer, 50);
  51.             }
  52.             if (i == 2) {   /*光标ON */
  53.                 cons.cur_c = COL8_FFFFFF;
  54.             }
  55.             if (i == 3) {   /*光标OFF */
  56.                 boxfill8(sheet->buf, sheet->bxsize, COL8_000000,
  57.                             cons.cur_x, cons.cur_y, cons.cur_x + 7, cons.cur_y + 15);
  58.                 cons.cur_c = -1;
  59.             }
  60.             if (256 <= i && i <= 511) { /*键盘数据（通过任务A）*/
  61.                 if (i == 8 + 256) {
  62.                     /*退格键*/
  63.                     if (cons.cur_x > 16) {
  64.                         /*用空格擦除光标后将光标前移一位*/
  65.                         cons_putchar(&cons, ' ', 0);
  66.                         cons.cur_x -= 8;
  67.                     }
  68.                 } else if (i == 10 + 256) {
  69.                     /*回车键*/
  70.                     /*将光标用空格擦除后换行 */
  71.                     cons_putchar(&cons, ' ', 0);
  72.                     cmdline[cons.cur_x / 8 - 2] = 0;
  73.                     cons_newline(&cons);
  74.                     cons_runcmd(cmdline, &cons, fat, memtotal); /*运行命令*/
  75.                     /*显示提示符*/
  76.                     cons_putchar(&cons, '>', 1);
  77.                 } else {
  78.                     /*一般字符*/
  79.                     if (cons.cur_x < 240) {
  80.                         /*显示一个字符之后将光标后移一位*/
  81.                         cmdline[cons.cur_x / 8 - 2] = i - 256;
  82.                         cons_putchar(&cons, i - 256, 1);
  83.                     }
  84.                 }
  85.             }
  86.             /*重新显示光标*/
  87.             if (cons.cur_c >= 0) {
  88.                 boxfill8(sheet->buf, sheet->bxsize, cons.cur_c, cons.cur_x, cons.cur_y, 
  89.                     cons.cur_x + 7, cons.cur_y + 15);
  90.             }
  91.             sheet_refresh(sheet, cons.cur_x, cons.cur_y, cons.cur_x + 8, cons.cur_y + 16);
  92.         }
  93.     }
  94. }
  96. void cons_putchar(struct CONSOLE *cons, int chr, char move)
  97. {
  98.     char s[2];
  99.     s[0] = chr;
  100.     s[1] = 0;
  101.     if (s[0] == 0x09) { /*制表符*/
  102.         for (;;) {
  103.             putfonts8_asc_sht(cons->sht, cons->cur_x, cons->cur_y, COL8_FFFFFF, COL8_000000, " ", 1);
  104.             cons->cur_x += 8;
  105.             if (cons->cur_x == 8 + 240) {
  106.                 cons_newline(cons);
  107.             }
  108.             if (((cons->cur_x - 8) & 0x1f) == 0) {
  109.                 break;  /*被32整除则break*/
  110.             }
  112.         }
  113.     } else if (s[0] == 0x0a) {  /*换行*/
  114.         cons_newline(cons);
  115.     } else if (s[0] == 0x0d) {  /*回车*/
  116.         /*先不做任何操作*/
  117.     } else {    /*一般字符*/
  118.         putfonts8_asc_sht(cons->sht, cons->cur_x, cons->cur_y, COL8_FFFFFF, COL8_000000, s, 1);
  119.         if (move != 0) {
  120.             /* move为0时光标不后移*/
  121.             cons->cur_x += 8;
  122.             if (cons->cur_x == 8 + 240) {
  123.                 cons_newline(cons);
  124.             }
  125.         }
  126.     }
  127.     return;
  128. }
  130. void cons_newline(struct CONSOLE *cons)
  131. {
  132.     int x, y;
  133.     struct SHEET *sheet = cons->sht;
  134.     if (cons->cur_y < 28 + 112) {
  135.         cons->cur_y += 16; /*到下一行*/
  136.     } else {
  137.         /*滚动*/
  138.         for (y = 28; y < 28 + 112; y++) {
  139.             for (x = 8; x < 8 + 240; x++) {
  140.                 sheet->buf[x + y * sheet->bxsize] = sheet->buf[x + (y + 16) * sheet->bxsize];
  141.             }
  142.         }
  143.         for (y = 28 + 112; y < 28 + 128; y++) {
  144.             for (x = 8; x < 8 + 240; x++) {
  145.                 sheet->buf[x + y * sheet->bxsize] = COL8_000000;
  146.             }
  147.         }
  148.         sheet_refresh(sheet, 8, 28, 8 + 240, 28 + 128);
  149.     }
  150.     cons->cur_x = 8;
  151.     return;
  152. }
  154. void cons_runcmd(char *cmdline, struct CONSOLE *cons, int *fat, unsigned int memtotal)
  155. {
  156.     if (strcmp(cmdline, "mem") == 0) {
  157.         cmd_mem(cons, memtotal);
  158.     } else if (strcmp(cmdline, "cls") == 0) {
  159.         cmd_cls(cons);
  160.     } else if (strcmp(cmdline, "dir") == 0) {
  161.         cmd_dir(cons);
  162.     } else if (strncmp(cmdline, "type ", 5) == 0) {
  163.         cmd_type(cons, fat, cmdline);
  164.     } else if (strcmp(cmdline, "hlt") == 0) {
  165.         cmd_hlt(cons, fat);
  166.     } else if (cmdline[0] != 0) {
  167.         /*不是命令，也不是空行*/
  168.         putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, "Bad command.", 12);
  169.         cons_newline(cons);
  170.         cons_newline(cons);
  171.     }
  172.     return;
  173. }
  175. void cmd_mem(struct CONSOLE *cons, unsigned int memtotal)
  176. {
  178.     struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
  179.     char s[30];
  180.     sprintf(s, "total   %dMB", memtotal / (1024 * 1024));
  181.     putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, s, 30);
  182.     cons_newline(cons);
  183.     sprintf(s, "free %dKB", memman_total(memman) / 1024);
  184.     putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, s, 30);
  185.     cons_newline(cons);
  186.     cons_newline(cons);
  187.     return;
  188. }
  190. void cmd_cls(struct CONSOLE *cons)
  191. {
  192.     int x, y;
  193.     struct SHEET *sheet = cons->sht;
  194.     for (y = 28; y < 28 + 128; y++) {
  195.         for (x = 8; x < 8 + 240; x++) {
  196.             sheet->buf[x + y * sheet->bxsize] = COL8_000000;
  197.         }
  198.     }
  199.     sheet_refresh(sheet, 8, 28, 8 + 240, 28 + 128);
  200.     cons->cur_y = 28;
  201.     return;
  202. }
  204. void cmd_dir(struct CONSOLE *cons)
  205. {
  206.     struct FILEINFO *finfo = (struct FILEINFO *) (ADR_DISKIMG + 0x002600);
  207.     int i, j;
  208.     char s[30];
  209.     for (i = 0; i < 224; i++) {
  210.         if (finfo[i].name[0] == 0x00) {
  211.             break;
  212.         }
  213.         if (finfo[i].name[0] != 0xe5) {
  214.             if ((finfo[i].type & 0x18) == 0) {
  215.                 sprintf(s, "filename.ext   %7d", finfo[i].size);
  216.                 for (j = 0; j < 8; j++) {
  217.                     s[j] = finfo[i].name[j];
  218.                 }
  219.                 s[ 9] = finfo[i].ext[0];
  220.                 s[10] = finfo[i].ext[1];
  221.                 s[11] = finfo[i].ext[2];
  222.                 putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, s, 30);
  223.                 cons_newline(cons);
  224.             }
  225.         }
  226.     }
  227.     cons_newline(cons);
  228.     return;
  229. }
  231. void cmd_type(struct CONSOLE *cons, int *fat, char *cmdline)
  232. {
  233.     struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
  234.     struct FILEINFO *finfo = file_search(cmdline + 5, (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
  235.     char *p;
  236.     int i;
  237.     if (finfo != 0) {
  238.         /*找到文件的情况*/
  239.         p = (char *) memman_alloc_4k(memman, finfo->size);
  240.         file_loadfile(finfo->clustno, finfo->size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
  241.         for (i = 0; i < finfo->size; i++) {
  242.             cons_putchar(cons, p[i], 1);
  244.         }
  245.         memman_free_4k(memman, (int) p, finfo->size);
  246.     } else {
  247.         /*没有找到文件的情况*/
  248.         putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, "File not found.",  15);
  249.         cons_newline(cons);
  250.     }
  251.     cons_newline(cons);
  252.     return;
  253. }
  255. void cmd_hlt(struct CONSOLE *cons, int *fat)
  256. {
  257.     struct MEMMAN *memman = (struct MEMMAN *) MEMMAN_ADDR;
  258.     struct FILEINFO *finfo = file_search("HLT.HRB", (struct FILEINFO *) (ADR_DISKIMG + 0x002600), 224);
  259.     struct SEGMENT_DESCRIPTOR *gdt = (struct SEGMENT_DESCRIPTOR *) ADR_GDT;
  260.     char *p;
  261.     if (finfo != 0) {
  262.         /*找到文件的情况*/
  263.         p = (char *) memman_alloc_4k(memman, finfo->size);
  264.         file_loadfile(finfo->clustno, finfo->size, p, fat, (char *) (ADR_DISKIMG + 0x003e00));
  265.         set_segmdesc(gdt + 1003, finfo->size - 1, (int) p, AR_CODE32_ER);
  266.         farjmp(0, 1003 * 8);
  267.         memman_free_4k(memman, (int) p, finfo->size);
  268.     } else {
  269.         /*没有找到文件的情况*/
  270.         putfonts8_asc_sht(cons->sht, 8, cons->cur_y, COL8_FFFFFF, COL8_000000, "File not found.", 15);
  271.         cons_newline(cons);
  272.     }
  273.     cons_newline(cons);
  274.     return;
  275. }

本次的file.c节选

  1. struct FILEINFO *file_search(char *name, struct FILEINFO *finfo, int max)
  2. {
  3.     int i, j;
  4.     char s[12];
  5.     for (j = 0; j < 11; j++) {
  6.         s[j] = ' ';
  7.     }
  8.     j = 0;
  9.     for (i = 0; name[i] != 0; i++) {
  10.         if (j >= 11) { return 0; /*没有找到*/ }
  11.         if (name[i] == '.' && j <= 8) { 
  12.             j = 8;
  13.         } else {
  14.             s[j] = name[i];
  15.             if ('a' <= s[j] && s[j] <= 'z') {
  16.                 /*将小写字母转换为大写字母*/
  17.                 s[j] -= 0x20;
  18.             } 
  19.             j++;
  20.         }
  21.     }
  22.     for (i = 0; i < max; ) {
  23.         if (finfo[i].name[0] == 0x00) {
  24.             break;
  25.         }
  26.         if ((finfo[i].type & 0x18) == 0) {
  27.             for (j = 0; j < 11; j++) {
  28.                 if (finfo[i].name[j] != s[j]) {
  29.                     goto next;
  30.                 }
  31.             }
  32.             return finfo + i; /*找到文件*/
  34.         }
  35. next:
  36.         i++;
  37.     }
  38.     return 0; /*没有找到*/
  39. }

■■■■■

嗯嗯，比之前的代码易读多了。你看，只要想把代码写得清爽些就一定能做到的，连笔者都做到了嘛（笑）。这个例子说明，如果持续增加新的功能，一个函数的代码就会变得很长，像这样定期整理一下还是很有帮助的。

好了，我们来“make run”，输入一些命令试试看。和之前运行的情况一样，很好。