TempleOSCDV3.11.ISO

Kernel/SerialDev/InputPointer.CPP

@@ -0,0 +1,84 @@
+U0 GridInit()
+{//Init input pointer grid struct. See $LK,"::/Demo/Graphics/Grid.CPP"$.
+  ip_grid.x=ip_grid.y=ip_grid.z=8;
+  ip_grid.x_offset=ip_grid.y_offset=ip_grid.z_offset=0;
+  ip_grid.x_speed =ip_grid.y_speed =ip_grid.z_speed =1;
+  ip_grid.show=ip_grid.snap=FALSE;
+}
+
+U0 IPVarsUpdate(I64 x,I64 y,I64 z,Bool l,Bool r)
+{
+  ip.presnap.x=ToI64(ip.scale.x*x)+ip.offset.x;
+  ip.presnap.y=ToI64(ip.scale.y*y)+ip.offset.y;
+  ip.presnap.z=ToI64(ip.scale.z*z)+ip.offset.z;
+  if (ip_grid.snap) {
+    ip.pos.x=Trunc(ip.presnap.x/ip_grid.x)*ip_grid.x+ip_grid.x_offset;
+    ip.pos.y=Trunc(ip.presnap.y/ip_grid.y)*ip_grid.y+ip_grid.y_offset;
+    ip.pos.z=Trunc(ip.presnap.z/ip_grid.z)*ip_grid.z+ip_grid.z_offset;
+  } else {
+    ip.pos.x=ip.presnap.x;
+    ip.pos.y=ip.presnap.y;
+    ip.pos.z=ip.presnap.z;
+  }
+
+  ip.pos.x=ClampI64(ip.pos.x,0,GR_WIDTH-1);
+  ip.pos.y=ClampI64(ip.pos.y,0,GR_HEIGHT-1);
+  ip.throttle=ClampI64(ip.throttle,MIN_I32,MAX_I32);
+  ip.pos_text.x=ip.pos.x/FONT_WIDTH;
+  if (ip.pos_text.x>=text.cols) {
+    ip.pos_text.x=text.cols-1;
+    ip.pos.x=text.cols*FONT_WIDTH-1;
+  }
+  ip.pos_text.y=ip.pos.y/FONT_HEIGHT;
+  if (ip.pos_text.y>=text.rows) {
+    ip.pos_text.y=text.rows-1;
+    ip.pos.y=text.rows*FONT_HEIGHT-1;
+  }
+  ip.lb=l;
+  ip.rb=r;
+  LBEqu(&kbd.scan_code,SCf_IP_L_DOWN,ip.lb);
+  LBEqu(&kbd.scan_code,SCf_IP_R_DOWN,ip.rb);
+}
+
+U0 IPSet(I64 x=MAX_I64,I64 y=MAX_I64,I64 z=MAX_I64,I64 l=MAX_I64,I64 r=MAX_I64)
+{//Note: Generates a message. See $LK,"IPSet",A="FF:::/Demo/Games/Zing.CPP,IPSet"$().
+  if (!(0<=x<GR_WIDTH))
+    x=ip.pos.x;
+  if (!(0<=y<GR_HEIGHT))
+    y=ip.pos.y;
+  if (z==MAX_I64)
+    z=ip.pos.z;
+
+  if (!(FALSE<=l<=TRUE))
+    l=ip.lb;
+  if (!(FALSE<=r<=TRUE))
+    r=ip.rb;
+
+  x=(x-ip.offset.x)/ip.scale.x;
+  y=(y-ip.offset.y)/ip.scale.y;
+  z=(z-ip.offset.z)/ip.scale.z;
+  IPVarsUpdate(x,y,z,l,r);
+  switch (ip.dev) {
+    case IP_MOUSE:
+      MouseIPSet(x,y,z,l,r);
+      break;
+  }
+}
+
+U0 IPVarsInit()
+{
+  MemSet(&ip,0,sizeof(CIPStateGlbls));
+  MemSet(&ip_last,0,sizeof(CIPStateGlbls));
+  ip.throttle=0;
+  ip.throttle_step=(MAX_I32+1)>>3;
+  ip.offset.x=ip.offset.y=ip.offset.z=0;
+  ip.scale.x=ip.scale.y=ip.scale.z=1.0;
+  ip.dev=IP_NULL;
+  ip.pos_text.x=ip.pos_text.y=ip.pos_text.z=0;
+  ip.has_wheel=FALSE;
+  ip.show=TRUE;
+  ip.speed=0;
+  ip.timestamp=GetTSC;
+  ip.dbl_time=0.350;
+  GridInit;
+}

Kernel/SerialDev/Keyboard.CPP

@@ -0,0 +1,488 @@
+asm {
+NORMAL_KEY_SCAN_DECODE_TABLE::
+	DU8	0,CH_ESC,"1234567890-=",CH_BACKSPACE,'\t';
+	DU8	"qwertyuiop[]",'\n',0,"as";
+	DU8	"dfghjkl;'\`",0,"\\zxcv";
+	DU8	"bnm,./",0,'*',0,CH_SPACE,0,0,0,0,0,0;
+	DU8	0,0,0,0,0,0,0,0,0,0,'-',0,0,0,'+',0;
+SHIFT_KEY_SCAN_DECODE_TABLE::
+	DU8	0,CH_SHIFT_ESC,"!@#$$%^&*()_+",CH_BACKSPACE,'\t';
+	DU8	"QWERTYUIOP{}",'\n',0,"AS";
+	DU8	"DFGHJKL:\"~",0,"|ZXCV";
+	DU8	"BNM<>?",0,'*',0,CH_SHIFT_SPACE,0,0,0,0,0,0;
+	DU8	0,0,0,0,0,0,0,0,0,0,'-',0,0,0,'+',0;
+CTRL_KEY_SCAN_DECODE_TABLE::
+	DU8	0,CH_ESC,"1234567890-=",CH_BACKSPACE,'\t';
+	DU8	CH_CTRLQ,CH_CTRLW,CH_CTRLE,CH_CTRLR,CH_CTRLT,CH_CTRLY,CH_CTRLU,
+		CH_CTRLI,CH_CTRLO,CH_CTRLP,"[]",'\n',0,CH_CTRLA,CH_CTRLS;
+	DU8	CH_CTRLD,CH_CTRLF,CH_CTRLG,CH_CTRLH,CH_CTRLJ,CH_CTRLK,CH_CTRLL,
+		";'\`",0,"\\",CH_CTRLZ,CH_CTRLX,CH_CTRLC,CH_CTRLV;
+	DU8	CH_CTRLB,CH_CTRLN,CH_CTRLM,",./",0,'*',0,CH_SPACE,0,0,0,0,0,0;
+	DU8	0,0,0,0,0,0,0,0,0,0,'-',0,0,0,'+',0;
+}
+
+U0 KbdCmdSend(I64 port, U8 val)
+{
+  F64 timeout=tS+0.125;
+  while (tS<timeout) {
+    if (!(InU8(KBD_CTRL)&2)) {
+      OutU8(port,val);
+      return;
+    }
+  }
+  throw;
+}
+
+I64 KbdCmdRead()
+{
+  F64 timeout=tS+0.125;
+  while (tS<timeout)
+    if (InU8(KBD_CTRL)&1)
+      return InU8(KBD_PORT);
+  throw;
+}
+
+U0 KbdCmdFlush()
+{
+  F64 timeout=tS+0.03;
+  while (tS<timeout)
+    InU8(KBD_PORT);
+}
+
+U0 KbdSetLEDs(I64 sc)
+{
+  U8 v=0;
+  BEqu(&v,0,Bt(&sc,SCf_SCROLL));
+  BEqu(&v,1,Bt(&sc,SCf_NUM));
+  BEqu(&v,2,Bt(&sc,SCf_CAPS));
+  try {
+    KbdCmdSend(KBD_PORT,0xED);
+    KbdCmdSend(KBD_PORT,v);
+  } catch
+    Fs->catch_except=TRUE;
+}
+
+U0 KbdMouseCmdAck(U8 val)
+{
+  I64 ack,timeout=5;
+  do {
+    ack=0;
+    try {
+      KbdCmdSend(KBD_CTRL,0xD4);
+      KbdCmdSend(KBD_PORT,val);
+      ack=KbdCmdRead;
+    } catch {
+      KbdCmdFlush;
+      Fs->catch_except=TRUE;
+    }
+  } while (ack!=0xFA && --timeout);
+  if (!timeout)
+    throw;
+}
+
+U0 KbdTypeMatic(U8 delay)
+{//Set speed of repeated keys.
+  try {
+    KbdCmdSend(KBD_CTRL,0xA7); //Disable Mouse
+    KbdCmdSend(KBD_CTRL,0xAE); //Enable Keyboard
+    KbdCmdSend(KBD_PORT,0xF3);
+    KbdCmdSend(KBD_PORT,delay); //Typematic rate
+    KbdCmdSend(KBD_CTRL,0xA8); //Enable Mouse
+  } catch {
+    KbdCmdFlush;
+    Fs->catch_except=TRUE;
+  }
+}
+
+I64 Char2ScanCode(I64 ch,I64 sc_flags=0)
+{//ASCII val to scan code (Slow).
+  I64 i;
+  U8 *table;
+  if (sc_flags) {
+    table=NORMAL_KEY_SCAN_DECODE_TABLE;
+    if (sc_flags & SCF_CTRL || ch<26)
+      table=CTRL_KEY_SCAN_DECODE_TABLE;
+    else if (sc_flags & SCF_SHIFT || 'A'<=ch<='Z') {
+      if (!(sc_flags & SCF_CAPS))
+	table=SHIFT_KEY_SCAN_DECODE_TABLE;
+    } else {
+      if (sc_flags & SCF_CAPS)
+	table=SHIFT_KEY_SCAN_DECODE_TABLE;
+    }
+    for (i=0;i<0x50;i++)
+      if (table[i]==ch)
+	return i|sc_flags;
+    return sc_flags;
+  } else {
+    table=NORMAL_KEY_SCAN_DECODE_TABLE;
+    for (i=0;i<0x50;i++)
+      if (table[i]==ch)
+	return i;
+    table=SHIFT_KEY_SCAN_DECODE_TABLE;
+    for (i=0;i<0x50;i++)
+      if (table[i]==ch)
+	return i|SCF_SHIFT;
+    table=CTRL_KEY_SCAN_DECODE_TABLE;
+    for (i=0;i<0x50;i++)
+      if (table[i]==ch)
+	return i|SCF_CTRL;
+    return 0;
+  }
+}
+
+U8 ScanCode2Char(I64 sc)
+{//Scan code to ASCII val.
+  U8 *table=NORMAL_KEY_SCAN_DECODE_TABLE;
+  if (sc&SCF_E0_PREFIX)
+    return 0;
+  if (sc&SCF_CTRL)
+    table=CTRL_KEY_SCAN_DECODE_TABLE;
+  else if (sc&SCF_SHIFT) {
+    if (!(sc&SCF_CAPS))
+      table=SHIFT_KEY_SCAN_DECODE_TABLE;
+  } else {
+    if (sc&SCF_CAPS)
+      table=SHIFT_KEY_SCAN_DECODE_TABLE;
+  }
+  sc&=0x7F;
+  if (sc>=0x50)
+    return 0;
+  else
+    return table[sc];
+}
+
+U8 scan_code_map[0x100]={
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,SC_SHIFT,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,SC_ENTER,SC_CTRL,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0x35,0,0,SC_ALT,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,SC_HOME,
+	SC_CURSOR_UP,SC_PAGE_UP,0,SC_CURSOR_LEFT,0,SC_CURSOR_RIGHT,0,SC_END,
+  SC_CURSOR_DOWN,SC_PAGE_DOWN,SC_INS,SC_DELETE,0,0,0,0,
+	0,0,0,0,SC_GUI,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+};
+
+U8 num_lock_map[0x100]={
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,8,9,10,0,5,6,7,0,2,
+  3,4,11,0x34,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,SC_ENTER,SC_CTRL,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0x35,0,0,SC_ALT,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,SC_HOME,
+	SC_CURSOR_UP,SC_PAGE_UP,0,SC_CURSOR_LEFT,0,SC_CURSOR_RIGHT,0,SC_END,
+  SC_CURSOR_DOWN,SC_PAGE_DOWN,SC_INS,SC_DELETE,0,0,0,0,
+	0,0,0,0,SC_GUI,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+  0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
+};
+
+U8 *Char2KeyName(I64 ch,Bool include_ctrl=TRUE)
+{//ASCII val to key name.
+  I64 i;
+  U8 buf[STR_LEN];
+  if (ch<=CH_SPACE) {
+    nobound_switch (ch) {
+      case '\n':
+	StrCpy(buf,"ENTER");
+	break;
+      case CH_BACKSPACE:
+	StrCpy(buf,"BACKSPACE");
+	break;
+      case '\t':
+	StrCpy(buf,"TAB");
+	break;
+      case CH_ESC:
+	StrCpy(buf,"ESC");
+	break;
+      case CH_SHIFT_ESC:
+	StrCpy(buf,"SHIFT_ESC");
+	break;
+      case 0: //nobound_switch
+      case 29:
+      case 30:
+	*buf=0;
+	break;
+      case CH_SHIFT_SPACE:
+	StrCpy(buf,"SHIFT_SPACE");
+	break;
+      case CH_SPACE:
+	StrCpy(buf,"SPACE");
+	break;
+      default:
+	if (include_ctrl)
+	  StrCpy(buf,"CTRL ");
+	buf[i=StrLen(buf)]=ch-1+'a';
+	buf[i+1]=0;
+	break;
+    }
+  } else if (Bt(chars_bmp_printable,ch)) {
+    *buf=ch;
+    buf[1]=0;
+  } else
+    *buf=0;
+  return StrNew(buf);
+}
+
+U8 *ScanCode2KeyName(I64 sc)
+{//Scan code to key name.
+  I64 ch;
+  U8 buf[STR_LEN],*st;
+  *buf=0;
+  if (sc&SCF_CTRL)
+    CatPrint(buf,"CTRL ");
+  if (sc&SCF_ALT)
+    CatPrint(buf,"ALT ");
+  if (sc&SCF_SHIFT)
+    CatPrint(buf,"SHIFT ");
+  if (sc&SCF_NO_SHIFT)
+    CatPrint(buf,"      ");
+  if (ch=ScanCode2Char(sc&255)) {
+    st=Char2KeyName(ch,FALSE);
+    StrCpy(buf+StrLen(buf),st);
+    Free(st);
+  } else {
+    switch (sc&255) {
+      case SC_BACKSPACE:CatPrint(buf,"BACK");	break;
+      case SC_CAPS:	CatPrint(buf,"CAPS");	break;
+      case SC_NUM:	CatPrint(buf,"NUM");	break;
+      case SC_SCROLL:	CatPrint(buf,"SCROLL");	break;
+      case SC_CURSOR_UP:CatPrint(buf,"UP");	break;
+      case SC_CURSOR_DOWN:CatPrint(buf,"DOWN");	break;
+      case SC_CURSOR_LEFT:CatPrint(buf,"LEFT");	break;
+      case SC_CURSOR_RIGHT:CatPrint(buf,"RIGHT"); break;
+      case SC_PAGE_UP:	CatPrint(buf,"PAGE_UP");  break;
+      case SC_PAGE_DOWN:CatPrint(buf,"PAGE_DOWN");break;
+      case SC_HOME:	CatPrint(buf,"HOME");	break;
+      case SC_END:	CatPrint(buf,"END");	break;
+      case SC_INS:	CatPrint(buf,"INS");	break;
+      case SC_DELETE:	CatPrint(buf,"DELETE");	break;
+      case SC_F1:	CatPrint(buf,"F1");	break;
+      case SC_F2:	CatPrint(buf,"F2");	break;
+      case SC_F3:	CatPrint(buf,"F3");	break;
+      case SC_F4:	CatPrint(buf,"F4");	break;
+      case SC_F5:	CatPrint(buf,"F5");	break;
+      case SC_F6:	CatPrint(buf,"F6");	break;
+      case SC_F7:	CatPrint(buf,"F7");	break;
+      case SC_F8:	CatPrint(buf,"F8");	break;
+      case SC_F9:	CatPrint(buf,"F9");	break;
+      case SC_F10:	CatPrint(buf,"F10");	break;
+      case SC_F11:	CatPrint(buf,"F11");	break;
+      case SC_F12:	CatPrint(buf,"F12");	break;
+      case SC_GUI:	CatPrint(buf,"WINDOWS");  break;
+      case SC_PRTSCRN1:	CatPrint(buf,"PRTSCRN1"); break;
+      case SC_PRTSCRN2:	CatPrint(buf,"PRTSCRN2"); break;
+    }
+  }
+  return StrNew(buf);
+}
+
+U0 KbdBuildSC(U8 raw_byte,Bool in_irq,U8 *_last_raw_byte,I64 *_last_sc)
+{
+  I64 ch,sc_flags,sc,sc2,sc_raw,new_key_f;
+  Bool set_LEDs=FALSE;
+  if (raw_byte==0xE0) {
+    *_last_raw_byte=raw_byte;
+    return;
+  } else {
+    sc=raw_byte;
+    BEqu(&sc,SCf_E0_PREFIX,*_last_raw_byte==0xE0);
+    BEqu(&sc,SCf_KEY_UP,raw_byte & 0x80);
+    *_last_raw_byte=raw_byte;
+  }
+  sc_flags=_last_sc->u32[0]&~0x1FF;
+  sc_raw=sc;
+
+  if (sc_flags & SCF_NUM) {
+    if (sc2=num_lock_map[sc.u8[0]])
+      sc.u8[0]=sc2;
+  } else {
+    if (sc2=scan_code_map[sc.u8[0]])
+      sc.u8[0]=sc2;
+  }
+
+  new_key_f=SCF_NEW_KEY;
+  if (sc&SCF_KEY_UP)
+    switch (sc&~SCF_KEY_UP) {
+      case SC_SHIFT:	sc_flags&=~SCF_SHIFT;	break;
+      case SC_CTRL:	sc_flags&=~SCF_CTRL;	break;
+      case SC_ALT:	sc_flags&=~SCF_ALT;	break;
+      case SC_DELETE:	sc_flags&=~SCF_DELETE;	break;
+      case SC_INS:	sc_flags&=~SCF_INS;	break;
+      case SC_CAPS:	sc_flags^=SCF_CAPS;	set_LEDs=TRUE;	break;
+      case SC_NUM:	sc_flags^=SCF_NUM;	set_LEDs=TRUE;	break;
+      case SC_SCROLL:	sc_flags^=SCF_SCROLL;	set_LEDs=TRUE;	break;
+    }
+  else
+    switch (sc) {
+      case SC_SHIFT:
+	if (Bts(&sc_flags,SCf_SHIFT)) new_key_f=0;
+	break;
+      case SC_CTRL:
+	if (Bts(&sc_flags,SCf_CTRL)) new_key_f=0;
+	break;
+      case SC_ALT:
+	if (Bts(&sc_flags,SCf_ALT)) new_key_f=0;
+	break;
+      case SC_DELETE:
+	sc_flags|=SCF_DELETE;
+	break;
+      case SC_INS:
+	sc_flags|=SCF_INS;
+	break;
+    }
+
+  sc_flags|=new_key_f;
+  sc=sc_flags|sc|(sc_flags|sc_raw)<<32;
+  if (sc_flags & SCF_CTRL && sc_flags & SCF_ALT) {
+    if (!(sc&SCF_KEY_UP)) {
+      if (sc&255==SC_DELETE && !(sc_flags & SCF_SHIFT))
+	CtrlAltDel(sc);
+      else {
+	if (sc&255==SC_ESC)
+	  ch='e';
+	else if (sc&255==SC_TAB)
+	  ch='t';
+	else
+	  ch=ScanCode2Char(sc&255);
+	if ('a'<=ch<='z') {
+	  sc&=~(SCF_NEW_KEY|SCF_NEW_KEY<<32);
+	  ch-='a';
+	  kbd.last_down_scan_code=sc;
+	  if (keydev.fp_ctrl_alt_cbs[ch] &&
+		Bt(&keydev.ctrl_alt_in_irq_flags,ch)==in_irq &&
+		(!(sc_flags & SCF_SHIFT)&&keydev.ctrl_alt_no_shift_descs[ch]) ||
+		sc_flags & SCF_SHIFT && keydev.ctrl_alt_shift_descs[ch])
+	    (*keydev.fp_ctrl_alt_cbs[ch])(sc);
+	}
+      }
+    }
+  }
+  if (set_LEDs && !in_irq)
+    KbdSetLEDs(sc);
+  *_last_sc=sc;
+}
+
+U0 KbdPktRead()
+{
+  static U8 last_raw_byte=0;
+  static I64 last_sc=0;
+  U8 raw_byte;
+  if (GetTSC>kbd.timestamp+cnts.time_stamp_freq>>3)
+    FifoU8Flush(kbd.fifo);
+  kbd.timestamp=GetTSC;
+  raw_byte=InU8(KBD_PORT);
+  KbdBuildSC(raw_byte,TRUE,&last_raw_byte,&last_sc);
+  if (!FifoU8Cnt(kbd.fifo)) {
+    FifoU8Ins(kbd.fifo,raw_byte);
+    if (raw_byte!=0xE0) {
+      while (FifoU8Rem(kbd.fifo,&raw_byte))
+	FifoU8Ins(kbd.fifo2,raw_byte);
+    }
+  } else {
+    FifoU8Ins(kbd.fifo,raw_byte);
+    while (FifoU8Rem(kbd.fifo,&raw_byte))
+      FifoU8Ins(kbd.fifo2,raw_byte);
+  }
+}
+
+interrupt U0 IRQKbd()
+{
+  CLD
+  OutU8(0x20,0x20);
+  kbd.irqs_working=TRUE;
+  if (mouse.install_in_progress) {
+    kbd.rst=TRUE;
+    return;
+  }
+  keydev.ctrl_alt_ret_addr=GetRBP()(I64)+8;
+  KbdPktRead;
+}
+
+U0 KbdInit()
+{
+  try {
+    KbdCmdFlush;
+    KbdCmdSend(KBD_CTRL,0xA7); //Disable Mouse
+    KbdCmdSend(KBD_CTRL,0xAE); //Enable Keyboard
+    KbdCmdSend(KBD_PORT,0xF0);
+    KbdCmdSend(KBD_PORT,0x02);
+    KbdSetLEDs(kbd.scan_code);
+  } catch {
+    KbdCmdFlush;
+    Fs->catch_except=TRUE;
+  }
+  IntEntrySet(0x21,&IRQKbd);
+  OutU8(0x21,InU8(0x21)&~2);
+}
+
+U0 KbdHandler()
+{
+  static U8 last_raw_byte=0;
+  U8  raw_byte;
+  FifoU8Rem(kbd.fifo2,&raw_byte);
+  KbdBuildSC(raw_byte,FALSE,&last_raw_byte,&kbd.scan_code);
+  if (raw_byte==0xE0) {
+    FifoU8Rem(kbd.fifo2,&raw_byte);
+    KbdBuildSC(raw_byte,FALSE,&last_raw_byte,&kbd.scan_code);
+  }
+  if (Btr(&kbd.scan_code,SCf_NEW_KEY)) {
+    kbd.new_key_timestamp=kbd.timestamp;
+    Btr(&kbd.scan_code,32+SCf_NEW_KEY);
+    FifoI64Ins(kbd.scan_code_fifo,kbd.scan_code);
+    kbd.cnt++;
+    if (!(kbd.scan_code&SCF_KEY_UP)) {
+      kbd.last_down_scan_code=kbd.scan_code;
+      Bts(kbd.down_bitmap,kbd.scan_code.u8[0]);
+      Bts(kbd.down_bitmap2,kbd.scan_code.u8[4]);
+    } else {
+      Btr(kbd.down_bitmap,kbd.scan_code.u8[0]);
+      Btr(kbd.down_bitmap2,kbd.scan_code.u8[4]);
+    }
+  }
+}
+
+I64 KbdMsgsQue()
+{
+  I64 a1,a2,msg_code=MSG_NULL;
+  CTask *task_focus;
+  if (task_focus=sys_focus_task) {
+    while (FifoI64Rem(kbd.scan_code_fifo,&a2)) {
+      a1=ScanCode2Char(a2);
+      if (a2 & SCF_KEY_UP) {
+	TaskMsg(task_focus,0,MSG_KEY_UP,a1,a2,0);
+	msg_code=MSG_KEY_UP;
+      } else {
+	TaskMsg(task_focus,0,MSG_KEY_DOWN,a1,a2,0);
+	msg_code=MSG_KEY_DOWN;
+      }
+    }
+  }
+  return msg_code;
+}
+
+I64 KbdMouseEvtTime()
+{//Timestamp of last key or mouse event.
+  if (mouse.timestamp>kbd.timestamp)
+    return mouse.timestamp;
+  else
+    return kbd.new_key_timestamp;
+}

Kernel/SerialDev/MakeSerialDev.CPP

@@ -0,0 +1,6 @@
+#exe {Cd(__DIR__);};
+#include "InputPointer"
+#include "Keyboard"
+#include "Mouse"
+#include "Message"
+#exe {Cd("..");};

Kernel/SerialDev/Message.CPP

@@ -0,0 +1,244 @@
+U0 InputFilterTask()
+{
+  CSrvCmd *tempc,*tempc1;
+  Bool old_filter;
+  I64 old_flags=GetRFlags;
+  Fs->win_inhibit=WIG_USER_TASK_DFT;
+  LBts(&Fs->task_flags,TASKf_INPUT_FILTER_TASK);
+  old_filter=LBts(&Fs->last_input_filter_task->task_flags,TASKf_FILTER_INPUT);
+  LBEqu(&Fs->task_flags,TASKf_FILTER_INPUT,old_filter);
+  while (TRUE) {
+    CLI
+    SrvCmdsHandler(old_flags);
+    tempc1=&Fs->srv_ctrl.next_waiting;
+    tempc=tempc1->next;
+    if (tempc==tempc1)
+      break;
+    else {
+      if (tempc->cmd_code==SVCT_TEXT_INPUT) {
+	QueRem(tempc);
+	SetRFlags(old_flags);
+	try
+		ExePrint("%s",tempc->aux_str);
+	catch
+	  Fs->catch_except=TRUE;
+	SrvCmdDel(tempc);
+      } else
+	break;
+    }
+  }
+  Fs->next_input_filter_task->last_input_filter_task=Fs->last_input_filter_task;
+  Fs->last_input_filter_task->next_input_filter_task=Fs->next_input_filter_task;
+  if (!old_filter)
+    LBtr(&Fs->last_input_filter_task->task_flags,TASKf_FILTER_INPUT);
+  SetRFlags(old_flags);
+}
+
+I64 ScanMsg(I64 *_a1=NULL,I64 *_a2=NULL,I64 mask=~1,CTask *task=NULL)
+{/*Check for a message of type specified by a one in the mask.
+Throw-out messages not in mask.
+If no message fit mask, return NULL immediately.
+Remove desired message, return $LK,"msg_code",A="MN:MSG_CMD"$.
+Note: This delivers messages from parent down to pop-up.
+*/
+  I64 result,old_flags;
+  CSrvCmd *tempc,*tempc1;
+  if (!task) task=Fs;
+  old_flags=GetRFlags;
+  tempc1=&task->srv_ctrl.next_waiting;
+  while (TRUE) {
+    CLI
+    if (task==Fs)
+      SrvCmdsHandler(old_flags);
+    tempc=tempc1->next;
+    if (tempc==tempc1)
+      break;
+    else {
+      if (tempc->cmd_code==SVCT_MSG) {
+	QueRem(tempc);
+	SetRFlags(old_flags);
+	result=tempc->msg_code;
+	if (_a1)
+	  *_a1=tempc->aux1;
+	if (_a2)
+	  *_a2=tempc->aux2;
+	SrvCmdDel(tempc);
+	if ((result!=MSG_KEY_DOWN || !(tempc->aux2&SCF_KEY_DESC) ||
+	      !Bt(&task->win_inhibit,WIf_SELF_KEY_DESC)) && Bt(&mask,result))
+	  goto sm_done;
+      }
+    }
+    SetRFlags(old_flags);
+  }
+  result=MSG_NULL;
+  if (_a1)
+    *_a1=0;
+  if (_a2)
+    *_a2=0;
+  if (task->parent_task&&task->parent_task->popup_task==task) {
+    SetRFlags(old_flags);
+    return ScanMsg(_a1,_a2,mask,task->parent_task);
+  }
+sm_done:
+  SetRFlags(old_flags);
+  return result;
+}
+
+I64 FlushMsgs(CTask *task=NULL)
+{//Throw away all messages.  Return count.
+  I64 result=0,a1,a2;
+  while (ScanMsg(&a1,&a2,~1,task))
+    result++;
+  return result;
+}
+
+I64 GetMsg(I64 *_a1=NULL,I64 *_a2=NULL,I64 mask=~1,CTask *task=NULL)
+{//Wait for a message of type specified by a one in the mask.
+//Throw-out all messages not in mask.
+  //Returns $LK,"msg_code",A="MN:MSG_CMD"$. See $LK,"::/Demo/MsgLoop.CPP"$.
+  I64 result;
+  if (!task) task=Fs;
+  LBtr(&task->task_flags,TASKf_IDLE);
+  while (!(result=ScanMsg(_a1,_a2,mask,task))) {
+    LBts(&task->task_flags,TASKf_IDLE);
+    Yield;
+  }
+  LBtr(&task->task_flags,TASKf_IDLE);
+  return result;
+}
+
+I64 ScanChar()
+{//Checks for $LK,"MSG_KEY_DOWN",A="MN:MSG_KEY_DOWN"$ and returns 0 immediately if no key.
+//Waits for $LK,"MSG_KEY_UP",A="MN:MSG_KEY_UP"$ of non-zero $LK,"ASCII",A="MN:CH_CTRLA"$ key and returns $LK,"ASCII",A="MN:CH_CTRLA"$ if key.
+  //$LK,"ScanMsg",A="MN:ScanMsg"$() throws away other message types.
+  I64 a1a,a2a,a1b,a2b;
+  if (!ScanMsg(&a1a,&a2a,1<<MSG_KEY_DOWN)||!a1a)
+    return 0;
+  else
+    do GetMsg(&a1b,&a2b,1<<MSG_KEY_UP);
+    while (!a1b);  //Be careful of $LK,"SC_SHIFT",A="MN:SC_SHIFT"$ and $LK,"SC_CTRL",A="MN:SC_CTRL"$, etc.
+  return a1a;
+}
+
+Bool ScanKey(I64 *_ch=NULL,I64 *_scan_code=NULL,Bool echo=FALSE)
+{//Checks for $LK,"MSG_KEY_DOWN",A="MN:MSG_KEY_DOWN"$ and returns FALSE immediately if no key.
+//Sets $LK,"ASCII",A="MN:CH_CTRLA"$ and $LK,"scan_code",A="FI:::/Doc/CharOverview.TXT"$.
+  //Removes key message and returns TRUE.
+  //$LK,"ScanMsg",A="MN:ScanMsg"$() throws away other message types.
+  I64 ch=0,sc=0;
+  if (ScanMsg(&ch,&sc,1<<MSG_KEY_DOWN)) {
+    if (_ch) *_ch=ch;
+    if (_scan_code) *_scan_code=sc;
+    if (echo)
+      PutKey(ch,sc);
+    return TRUE;
+  } else {
+    if (_ch) *_ch=0;
+    if (_scan_code) *_scan_code=0;
+    return FALSE;
+  }
+}
+
+I64 GetKey(I64 *_scan_code=NULL,Bool echo=FALSE,Bool raw_cursor=FALSE)
+{//Waits for $LK,"MSG_KEY_DOWN",A="MN:MSG_KEY_DOWN"$ message and returns $LK,"ASCII",A="MN:CH_CTRLA"$.
+//Sets $LK,"scan_code",A="FI:::/Doc/CharOverview.TXT"$.
+  //$LK,"ScanKey",A="MN:ScanKey"$() throws away other message types.
+  I64 ch,sc;
+  Bool cursor_on=FALSE;
+  while (!ScanKey(&ch,&sc,FALSE)) {
+    if (IsRaw && raw_cursor) {
+      if (!cursor_on && ToI64(GetTSC*5/cnts.time_stamp_freq)&1) {
+	'Û';
+	cursor_on=TRUE;
+      } else if (cursor_on && !(ToI64(GetTSC*5/cnts.time_stamp_freq)&1)) {
+	'' CH_BACKSPACE;
+	cursor_on=FALSE;
+      }
+    }
+    LBts(&Fs->task_flags,TASKf_IDLE);
+    if (IsDbg) {
+//We don't want interrupt-driven keyboard when in debugger
+      //because that could have side-effects or crash, so we poll
+      //keyboard when in debugger with interrupts off.
+      PUSHFD
+      CLI
+      KbdMouseHandler(TRUE,FALSE);
+      KbdMsgsQue;
+      POPFD
+    } else {
+      LBts(&Fs->task_flags,TASKf_AWAITING_MSG);
+      Yield;
+    }
+    LBtr(&Fs->task_flags,TASKf_IDLE);
+  }
+  if (IsRaw && raw_cursor && cursor_on)
+    '' CH_BACKSPACE;
+  if (echo)
+    PutKey(ch,sc);
+  if (_scan_code) *_scan_code=sc;
+  return ch;
+}
+
+I64 GetChar(I64 *_scan_code=NULL,Bool echo=TRUE,Bool raw_cursor=FALSE)
+{//Waits for non-zero $LK,"ASCII",A="MN:CH_CTRLA"$ key.
+//Sets $LK,"scan_code",A="FI:::/Doc/CharOverview.TXT"$.
+  I64 ch1;
+  do ch1=GetKey(_scan_code,FALSE,raw_cursor);
+  while (!ch1);
+  if (echo)
+    "$$PT$$%c$$FG$$",ch1;
+  return ch1;
+}
+
+U8 *GetStr(U8 *msg=NULL,U8 *dft=NULL,I64 flags=0)
+{//Returns a $LK,"MAlloc",A="MN:MAlloc"$()ed prompted string.  See $LK,"Flags",A="MN:GSF_SHIFT_ESC_EXIT"$.
+  U8 *st;
+  if (msg)
+    "" msg,dft;
+  st=(*fp_getstr2)(flags);
+  if (!*st) {
+    Free(st);
+    if (dft)
+      return StrNew(dft);
+    else
+      return StrNew("");
+  }
+  return st;
+}
+
+I64 GetS(U8 *buf,I64 size,Bool allow_ext=TRUE)
+{//Prompt into fixed length string. Size must include terminator.
+  U8 *st;
+  I64 ch,i=0;
+  if (!size || !buf) return 0;
+  if (allow_ext) {
+    st=GetStr;
+    if (StrLen(st)>size-1) {
+      MemCpy(buf,st,size-1);
+      buf[size-1]=0;
+    } else
+      StrCpy(buf,st);
+    i=StrLen(buf);
+    Free(st);
+  } else {
+    while (TRUE) {
+      ch=GetChar(,FALSE,IsDbg);
+      if (ch=='\n') {
+	'' ch;
+	break;
+      } else if (ch==CH_BACKSPACE) {
+	if (i>0) {
+	  i--;
+	  '' ch;
+	}
+      } else {
+	if (i<size-1) {
+	  buf[i++]=ch;
+	  '' ch;
+	}
+      }
+    }
+    buf[i]=0;
+  }
+  return i;
+}

Kernel/SerialDev/Mouse.CPP

@@ -0,0 +1,313 @@
+U0 MousePktRead()
+{
+  U8 j;
+  if (GetTSC>mouse.timestamp+cnts.time_stamp_freq>>3)
+    FifoU8Flush(mouse.fifo);
+  mouse.timestamp=GetTSC;
+  FifoU8Ins(mouse.fifo,InU8(KBD_PORT));
+  if (FifoU8Cnt(mouse.fifo)==mouse.pkt_size)
+    while (FifoU8Rem(mouse.fifo,&j))
+      FifoU8Ins(mouse.fifo2,j);
+}
+
+interrupt U0 IRQMouse()
+{
+  CLD
+  OutU8(0xA0,0x20);
+  OutU8(0x20,0x20);
+  mouse.irqs_working=TRUE;
+  if (mouse.install_in_progress || !mouse.installed) {
+    kbd.rst=TRUE;
+    return;
+  }
+  MousePktRead;
+}
+
+U0 MouseGetDevType()
+{
+  I64 b;
+  KbdMouseCmdAck(0xF2);
+  b=KbdCmdRead;
+  if (b==3)
+    mouse.has_wheel=TRUE;
+  else if (b==4)
+    mouse.has_ext_buttons=TRUE;
+}
+
+Bool MouseRst()
+{
+  U8 b,*_b;
+  U16 *_w;
+  F64 timeout;
+  Bool result=FALSE,present;
+
+  mouse.has_wheel=FALSE;
+  mouse.has_ext_buttons=FALSE;
+
+  _w=0x40E;
+  present=MemPagePresentMark(_w,TRUE);
+  if (*_w==0x9FC0) {
+    _b=0x9FC00+0x30;
+    *_b=1; //This enables my mouse.  It might be for one machine.
+//USB DMA packets, set-up by BIOS to make legacy PS/2?
+  }
+  if (!present)
+    MemPagePresentMark(_w,FALSE);
+
+  try {
+    KbdCmdFlush;
+    KbdCmdSend(KBD_CTRL,0xAD); //Disable Kbd
+    KbdCmdSend(KBD_CTRL,0xA8); //Enable Mouse
+
+    KbdMouseCmdAck(0xFF); //Rst
+
+    timeout=tS+10.0;
+    do
+      try {
+	KbdCmdRead;
+	timeout=0; //force exit
+      } catch
+	Fs->catch_except=TRUE;
+    while (tS<timeout);
+
+    try
+	    KbdCmdRead;
+    catch
+      Fs->catch_except=TRUE;
+
+    KbdMouseCmdAck(0xF3);
+    KbdMouseCmdAck(200);
+    KbdMouseCmdAck(0xF3); // enable Mouse
+    KbdMouseCmdAck(100); // Set Rate
+    KbdMouseCmdAck(0xF3);
+    KbdMouseCmdAck(80); //Resolution
+
+    MouseGetDevType; // enable Mouse
+
+    KbdMouseCmdAck(0xF3);
+    KbdMouseCmdAck(10);
+    MouseGetDevType; // enable Mouse
+
+    KbdMouseCmdAck(0xE8); //Resolution
+    KbdMouseCmdAck(0x03);
+    KbdMouseCmdAck(0xE6);
+
+    KbdMouseCmdAck(0xF3); // Set Rate
+    KbdMouseCmdAck(100);
+
+    KbdMouseCmdAck(0xF4); // enable Mouse
+    result=TRUE;
+
+    //Enable IRQ 12
+    KbdCmdSend(KBD_CTRL,0x20);
+    b=KbdCmdRead;
+    KbdCmdSend(KBD_CTRL,0x60);
+    KbdCmdSend(KBD_PORT,(b|2)&~0x20);
+
+  } catch
+    Fs->catch_except=TRUE;
+
+    //This is been added to override failure
+    //because the mouse sometimes still works.
+  result=TRUE;
+
+  try
+	  KbdCmdSend(KBD_CTRL,0xAE); //Enable Keyboard
+  catch
+    Fs->catch_except=TRUE;
+  if (mouse.has_wheel || mouse.has_ext_buttons)
+    mouse.pkt_size=4;
+  else
+    mouse.pkt_size=3;
+  if (!result)
+    try
+	    KbdCmdSend(KBD_CTRL,0xA7); //Disable Mouse
+    catch
+      Fs->catch_except=TRUE;
+  return result;
+}
+
+U0 MouseSpeedSet()
+{
+  I64 dd,temp;
+  if ((dd=SqrI64(mouse_last.pos.x-mouse.pos.x)
+	+SqrI64(mouse_last.pos.y-mouse.pos.y)) &&
+	(temp=mouse.timestamp-mouse_last.timestamp))
+    mouse.speed=Sqrt(dd)*cnts.time_stamp_freq/temp;
+  mouse_last.timestamp=mouse.timestamp;
+}
+
+U0 MouseUpdatePre()
+{
+  I64 old_timestamp=mouse_last.timestamp;
+  MemCpy(&mouse_last,&mouse,sizeof(CMouseStateGlbls));
+  mouse_last.timestamp=old_timestamp;
+}
+
+U0 MouseUpdatePost()
+{
+  I64 i;
+  mouse.pos.x=mouse.prescale.x*mouse.scale.x*ip_grid.x_speed;
+  mouse.pos.y=mouse.prescale.y*mouse.scale.y*ip_grid.y_speed;
+  mouse.pos.z=mouse.prescale.z*mouse.scale.z*ip_grid.z_speed;
+
+  i=Trunc(ip.scale.x*mouse.pos.x/ip_grid.x)*ip_grid.x+ip.offset.x;
+//TODO ip_grid.x_offset?
+  if (i<0)
+    ip.offset.x-=i;
+  else if (i>=GR_WIDTH)
+    ip.offset.x+=GR_WIDTH-1-i;
+
+  i=Trunc(ip.scale.y*mouse.pos.y/ip_grid.y)*ip_grid.y+ip.offset.y;
+  if (i<0)
+    ip.offset.y-=i;
+  else if (i>=GR_HEIGHT)
+    ip.offset.y+=GR_HEIGHT-1-i;
+
+  if (mouse.pos.x!=mouse_last.pos.x || mouse.pos.y!=mouse_last.pos.y ||
+	mouse.pos.z!=mouse_last.pos.z) {
+    mouse.evt=TRUE;
+    MouseSpeedSet;
+  } else
+    for (i=0;i<5;i++)
+      if (mouse.buttons[i]!=mouse_last.buttons[i]) {
+	mouse.evt=TRUE;
+	break;
+      }
+}
+
+U0 MouseHandler()
+{
+  I64 i,dx,dy,dz;
+  U8 mouse_buf[4];
+
+  MouseUpdatePre;
+  for (i=0;i<4;i++)
+    mouse_buf[i]=0;
+  for (i=0;i<mouse.pkt_size;i++)
+    if (!FifoU8Rem(mouse.fifo2,&mouse_buf[i]))
+      mouse_buf[i]=0;
+
+  mouse.buttons[0] = mouse_buf[0] & 1;
+  mouse.buttons[1] = (mouse_buf[0] & 2) >> 1;
+  mouse.buttons[2] = (mouse_buf[0] & 4) >> 2;
+  mouse.buttons[3] = (mouse_buf[3] & 0x10) >> 4;
+  mouse.buttons[4] = (mouse_buf[3] & 0x20) >> 5;
+  if (mouse_buf[0] & 0x10)
+    dx=mouse_buf[1]-256;
+  else
+    dx=mouse_buf[1];
+  if (mouse_buf[0] & 0x20)
+    dy=256-mouse_buf[2];
+  else
+    dy=-mouse_buf[2];
+  if (mouse_buf[3] & 0x08)
+    dz=mouse_buf[3]&7-8;
+  else
+    dz=mouse_buf[3]&7;
+
+  mouse.prescale.x+=dx;
+  mouse.prescale.y+=dy;
+  mouse.prescale.z+=dz;
+
+  MouseUpdatePost;
+}
+
+U0 MouseIPSet(I64 x,I64 y,I64 z,I64 l,I64 r)
+{
+  mouse.timestamp=GetTSC;
+  MouseUpdatePre;
+  mouse.prescale.x=x/mouse.scale.x/ip_grid.x_speed;
+  mouse.prescale.y=y/mouse.scale.y/ip_grid.y_speed;
+  mouse.prescale.z=z/mouse.scale.z/ip_grid.z_speed;
+  mouse.buttons[0]=l;
+  mouse.buttons[1]=r;
+  MouseUpdatePost;
+}
+
+U0 KbdMouseRst()
+{
+  KbdCmdFlush;
+  FifoU8Flush(kbd.fifo2);
+  FifoU8Flush(mouse.fifo2);
+  FifoI64Flush(kbd.scan_code_fifo);
+  kbd.scan_code=0;
+  kbd.rst=FALSE;
+}
+
+Bool MouseDriverInstall(I64 dummy=0) //can be spawned
+{
+  nounusedwarn dummy;
+  I64 i;
+  mouse.install_in_progress=TRUE;
+  OutU8(0xA1,InU8(0xA1)|0x10);
+  mouse.installed=mouse.irqs_working=FALSE;
+  IntEntrySet(0x2C,&IRQMouse);
+  for(i=0;i<5;i++)
+    mouse.buttons[i]=0;
+  if (i=MouseRst)
+    OutU8(0xA1,InU8(0xA1)&~0x10);
+  KbdMouseRst;
+  mouse.install_attempts++;
+  mouse.installed=mouse.evt=i;
+  mouse.install_in_progress=FALSE;
+  return mouse.installed;
+}
+
+U0 KbdMouseHandler(Bool poll_kbd,Bool poll_mouse)
+{
+  if (mouse.install_in_progress) {
+    Yield;
+    return;
+  }
+  if (kbd.rst)
+    KbdMouseRst;
+  else {
+    if (poll_mouse &&
+	  mouse.installed &&
+	  !mouse.irqs_working) {
+      PUSHFD
+      CLI
+      while (InU8(KBD_CTRL)&1)
+	MousePktRead;
+      POPFD
+    }
+
+    if (poll_kbd)
+      while (InU8(KBD_CTRL)&1)
+	KbdPktRead;
+
+    if (kbd.rst)
+      KbdMouseRst;
+    else {
+      while (FifoU8Cnt(kbd.fifo2))
+	KbdHandler;
+      while (FifoU8Cnt(mouse.fifo2))
+	if (mouse.installed)
+	  MouseHandler;
+	else
+	  KbdMouseRst;
+    }
+  }
+}
+
+U0 KbdMouseVarsInit()
+{
+  MemSet(&kbd,0,sizeof(CKbdStateGlbls));
+  kbd.fifo=FifoU8New(8);
+  kbd.fifo2=FifoU8New(64);
+  kbd.scan_code_fifo=FifoI64New(128);
+  kbd.irqs_working=FALSE;
+  MemSet(&mouse,0,sizeof(CMouseStateGlbls));
+  mouse.fifo=FifoU8New(8);
+  mouse.fifo2=FifoU8New(64);
+  mouse.scale.x=0.5;
+  mouse.scale.y=0.5;
+  mouse.scale.z=1.0;
+  mouse.prescale.x=GR_WIDTH/mouse.scale.x/2.0;
+  mouse.prescale.y=GR_HEIGHT/mouse.scale.y/2.0;
+  mouse.prescale.z=0/mouse.scale.z;
+  mouse.pos.x=GR_WIDTH>>1;
+  mouse.pos.y=GR_HEIGHT>>1;
+  MemCpy(&mouse_last,&mouse,sizeof(CMouseStateGlbls));
+}