4　实现字符输入（harib14d）

要实现字符的输入，只要在键盘被按下的时候向console_task的FIFO发送数据即可。但要发送数据，必须要知道struct FIFO的内存地址才行。唔，这可怎么办呢？

我们可以让任务A在创建task_cons的时候，顺便将FIFO也准备好。这样一来，任务A就能知道task_cons所使用的FIFO的地址，我们的问题便迎刃而解了。

等等，这样还是太麻烦了，我们还是把struct FIFO放到struct TASK里面去吧。基本上没有什么任务是完全用不到FIFO的，因此我们把它们绑定起来。

本次的bootpack.h节选

  1. struct TASK {
  2.     int sel, flags; /* sel代表GDT编号  */
  3.     int level, priority;
  4.     struct FIFO32 fifo; /*这里！ */
  5.     struct TSS32 tss;
  6. };

■■■■■

接下来我们来修改一下HariMain，使其判断key_to的值并向task_cons的FIFO发送数据。

本次的bootpack.c节选

  1. void HariMain(void)
  2. {
  3.     （中略）
  5.     for (;;) {
  6.         io_cli();
  7.         if (fifo32_status(&fifo) == 0) {
  8.             task_sleep(task_a);
  9.             io_sti();
  10.         } else {
  11.             i = fifo32_get(&fifo);
  12.             io_sti();
  13.             if (256 <= i && i <= 511) { /*键盘数据*/
  14.                 sprintf(s, "%02X", i - 256);
  15.                 putfonts8_asc_sht(sht_back, 0, 16, COL8_FFFFFF, COL8_008484, s, 2);
  16. /*从此开始*/    if (i < 0x54 + 256 && keytable[i - 256] != 0) { /*一般字符*/
  17.                     if (key_to == 0) {  /*发送给任务A */
  18.                         if (cursor_x < 128) {
  19.                             /*显示一个字符之后将光标后移一位*/
  20.                             s[0] = keytable[i - 256];
  21.                             s[1] = 0;
  22.                             putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, s, 1);
  23.                             cursor_x += 8;
  25.                         }
  26.                     } else {    /*发送给命令行窗口*/
  27.                         fifo32_put(&task_cons->fifo, keytable[i - 256] + 256);
  28. /*到此结束*/        }
  29.                 }
  30.                 if (i == 256 + 0x0e) {  /* 退格键 */
  31. /*从此开始*/        if (key_to == 0) {  /*发送给任务A */
  32.                         if (cursor_x > 8) {
  33.                             /*用空白擦除光标后将光标前移一位*/
  34.                             putfonts8_asc_sht(sht_win, cursor_x, 28, COL8_000000, COL8_FFFFFF, " ", 1);
  35.                             cursor_x -= 8;
  36.                         }
  37.                     } else {    /*发送给命令行窗口*/
  38.                         fifo32_put(&task_cons->fifo, 8 + 256);
  39. /*到此结束*/        }
  40.                 }
  41.                 if (i == 256 + 0x0f) { /* Tab键*/
  42.                     （中略）
  43.                 }
  44.                 /*重新显示光标*/
  45.                 boxfill8(sht_win->buf, sht_win->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
  46.                 sheet_refresh(sht_win, cursor_x, 28, cursor_x + 8, 44);
  47.             } else if (512 <= i && i <= 767) { /*鼠标数据*/
  48.                 （中略）
  49.             } else if (i <= 1) { /*光标用定时器*/
  50.                 （中略）
  51.             }
  52.         }
  53.     }
  54. }

当key_to不为0时，系统会向命令行窗口任务发送键盘数据，支持一般的字符输入和退格键。由于在命令行窗口中也使用了定时器等，为了不与键盘数据冲突，我们在写入FIFO的时候将键盘数据的值加上256。

在向命令行窗口发送键盘数据的时候，并不是直接发送从键盘接收到的原始数据，而是发送经过keytable[]转换后的值。究其原因，是由于这样做可以省去在命令行窗口任务中将按键编码转换成字符编码的步骤。

对于退格键，我们将它的字符编码定义为8，因为在ASCII码中，编码8就对应着退格键，我们只是和它接轨而已。当然，如果你不想用8也完全没有问题。

■■■■■

console_task也需要改写一下，因为我们必须让它能够接收并处理键盘数据。此外，我们还得把&fifo改写成&task—>fifo。

本次的bootpack.c节选

  1. void console_task(struct SHEET *sheet)
  2. {
  3.     struct TIMER *timer;
  4.     struct TASK *task = task_now();
  5.     int i, fifobuf[128], cursor_x = 16, cursor_c = COL8_000000;
  6.     char s[2];
  8.     fifo32_init(&task->fifo, 128, fifobuf, task);
  9.     timer = timer_alloc();
  10.     timer_init(timer, &task->fifo, 1);
  11.     timer_settime(timer, 50);
  13.     /*显示提示符*/
  14.     putfonts8_asc_sht(sheet, 8, 28, COL8_FFFFFF, COL8_000000, ">", 1);
  16.     for (;;) {
  17.         io_cli();
  18.         if (fifo32_status(&task->fifo) == 0) {
  19.             task_sleep(task);
  20.             io_sti();
  21.         } else {
  22.             i = fifo32_get(&task->fifo);
  23.             io_sti();
  24.             if (i <= 1) { /*光标用定时器*/
  25.                 if (i != 0) {
  26.                     timer_init(timer, &task->fifo, 0); /*接下来置0 */
  27.                     cursor_c = COL8_FFFFFF;
  28.                 } else {
  29.                     timer_init(timer, &task->fifo, 1); /*接下来置1 */
  30.                     cursor_c = COL8_000000;
  31.                 }
  32.                 timer_settime(timer, 50);
  33.             }
  34.             if (256 <= i && i <= 511) { /*键盘数据（通过任务A） */
  35.                 if (i == 8 + 256) {
  36.                     /*退格键*/
  37.                     if (cursor_x > 16) {
  38.                         /*用空白擦除光标后将光标前移一位*/
  39.                         putfonts8_asc_sht(sheet, cursor_x, 28, COL8_FFFFFF, COL8_000000, " ", 1);
  40.                         cursor_x -= 8;
  41.                     }
  42.                 } else {
  43.                     /*一般字符*/
  44.                     if (cursor_x < 240) {
  45.                         /*显示一个字符之后将光标后移一位  */
  46.                         s[0] = i - 256;
  47.                         s[1] = 0;
  48.                         putfonts8_asc_sht(sheet, cursor_x, 28, COL8_FFFFFF, COL8_000000, s, 1);
  49.                         cursor_x += 8;
  50.                     }
  51.                 }
  52.             }
  53.             /*重新显示光标*/
  54.             boxfill8(sheet->buf, sheet->bxsize, cursor_c, cursor_x, 28, cursor_x + 7, 43);
  55.             sheet_refresh(sheet, cursor_x, 28, cursor_x + 8, 44);
  56.         }
  57.     }
  58. }

上面的程序基本是由HariMain照猫画虎而来，唯一的一点区别就是开头显示提示符“>”的地方了。退格键的处理上也对可以删除的界限作了调整，以避免退格时擦掉提示符。

■■■■■

我们来运行一下看看，“make run”。

4　实现字符输入（harib14d） - 图1

可以输入了哦！

成功了，真是个伟大的胜利。现在我们可以输入英文、数字和符号了，但还无法输入“!”和“%”。好吧，接下来我们来解决这个问题。