TempleOSCDV4.08.ISO

2018-09-08 21:47:25 +02:00
1 parent b632ab9a4f
commit 2d56cda5f3
@@ -1,4 +1,4 @@
-U0 ATABlkSelect(CBlkDev *bd,I64 blk,I64 cnt)
+U0 ATABlkSel(CBlkDev *bd,I64 blk,I64 cnt)
 {
  if (bd->type!=BDT_ATAPI && bd->base1)
    OutU8(bd->base1+ATAR1_CTRL,0x8);
@@ -11,13 +11,13 @@ U0 ATABlkSelect(CBlkDev *bd,I64 blk,I64 cnt)
    OutU8(bd->base0+ATAR0_SECT,blk);
    OutU8(bd->base0+ATAR0_LCYL,blk.u8[1]);
    OutU8(bd->base0+ATAR0_HCYL,blk.u8[2]);
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  } else { //28 Bit LBA
    OutU8(bd->base0+ATAR0_NSECT,cnt);
    OutU8(bd->base0+ATAR0_SECT,blk);
    OutU8(bd->base0+ATAR0_LCYL,blk.u8[1]);
    OutU8(bd->base0+ATAR0_HCYL,blk.u8[2]);
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4|blk.u8[3]);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4|blk.u8[3]);
  }
 }

@@ -48,9 +48,9 @@ Bool ATAWaitDRQ(CBlkDev *bd,F64 timeout)
 Bool ATANop(CBlkDev *bd,F64 timeout)
 {
  if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
  OutU8(bd->base0+ATAR0_FEAT,0);
  OutU8(bd->base0+ATAR0_CMD,ATA_NOP);
  return ATAWaitNotBUSY(bd,timeout);
@@ -118,9 +118,9 @@ Bool ATAPIWritePktWord(CBlkDev *bd,F64 timeout,...)
 Bool ATAPISetMaxSpeed(CBlkDev *bd)
 {
  if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
  OutU8(bd->base0+ATAR0_LCYL,0);
  OutU8(bd->base0+ATAR0_HCYL,0);
  ATACmd(bd,ATA_PACKET);
@@ -131,9 +131,9 @@ Bool ATAPISetMaxSpeed(CBlkDev *bd)
 Bool ATAPISeek(CBlkDev *bd,I64 native_blk)
 {
  if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
  OutU8(bd->base0+ATAR0_LCYL,0);
  OutU8(bd->base0+ATAR0_HCYL,0);
  ATACmd(bd,ATA_PACKET);
@@ -149,9 +149,9 @@ Bool ATAPIStartStop(CBlkDev *bd,F64 timeout,Bool start)
  else
    i=0;
  if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
  ATACmd(bd,ATA_PACKET);
 //Start/Stop
  if (ATAPIWritePktWord(bd,timeout,0x1B00,0,i,0,0,0))
@@ -167,9 +167,9 @@ I64 ATAGetDevId(CBlkDev *bd,F64 timeout,U16 **_id_record)
  if (bd->type!=BDT_ATAPI && bd->base1)
    OutU8(bd->base1+ATAR1_CTRL,0x8);
  if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
  ATACmd(bd,ATA_ID_DEV);
  if (!ATAWaitNotBUSY(bd,timeout))
    return BDT_NULL;
@@ -191,9 +191,9 @@ I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)

  if (bd->type==BDT_ATAPI) {
    if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
    else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
    ATACmd(bd,ATA_DEV_RST);
    if (!ATAWaitNotBUSY(bd,0))
      okay=FALSE;
@@ -217,7 +217,7 @@ I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
  if (okay) {
    if (bd->flags & BDF_EXT_SIZE && bd->base1) {
      OutU8(bd->base1+ATAR1_CTRL,0x8);
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
      ATACmd(bd,ATA_READ_NATIVE_MAX_EXT);
      if (ATAWaitNotBUSY(bd,timeout)) {
 	res.u8[0]=InU8(bd->base0+ATAR0_SECT);
@@ -237,13 +237,13 @@ I64 ATAReadNativeMax(CBlkDev *bd,F64 timeout)
    } else {
      if (bd->type!=BDT_ATAPI && bd->base1)
 	OutU8(bd->base1+ATAR1_CTRL,0x8);
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
      ATACmd(bd,ATA_READ_NATIVE_MAX);
      if (ATAWaitNotBUSY(bd,timeout)) {
 	res.u8[0]=InU8(bd->base0+ATAR0_SECT);
 	res.u8[1]=InU8(bd->base0+ATAR0_LCYL);
 	res.u8[2]=InU8(bd->base0+ATAR0_HCYL);
-	res.u8[3]=InU8(bd->base0+ATAR0_SELECT) & 0xF;
+	res.u8[3]=InU8(bd->base0+ATAR0_SEL) & 0xF;
      }
    }
  }
@@ -257,9 +257,9 @@ I64 ATAPIReadCapacity(CBlkDev *bd,I64 *_blk_size=NULL)
  U32 buf[2];
  if (ATAWaitNotBUSY(bd,0)) {
    if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
    else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
    OutU8(bd->base0+ATAR0_LCYL,8);
    OutU8(bd->base0+ATAR0_HCYL,0);
    ATACmd(bd,ATA_PACKET);
@@ -280,9 +280,9 @@ CATAPITrack *ATAPIReadTrackInfo(CBlkDev *bd,I64 blk)
  Bool unlock=BlkDevLock(bd);
  if (ATAWaitNotBUSY(bd,0)) {
    if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
    else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
    OutU8(bd->base0+ATAR0_LCYL,sizeof(CATAPITrack)&0xFF);
    OutU8(bd->base0+ATAR0_HCYL,sizeof(CATAPITrack)>>8);
    ATACmd(bd,ATA_PACKET);
@@ -311,7 +311,7 @@ Bool ATAInit(CBlkDev *bd)

  if (ATAReadNativeMax(bd,tS+0.1)) {

-    ATABlkSelect(bd,bd->max_blk,0);
+    ATABlkSel(bd,bd->max_blk,0);
    if (bd->flags&BDF_EXT_SIZE)
      ATACmd(bd,ATA_SET_MAX_EXT);
    else
@@ -353,7 +353,7 @@ U0 ATAReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
  Bool unlock=BlkDevLock(bd);

  retry:
-  ATABlkSelect(bd,blk,cnt);
+  ATABlkSel(bd,blk,cnt);
  if (bd->flags & BDF_EXT_SIZE)
    ATACmd(bd,ATA_READ_MULTI_EXT);
  else
@@ -392,9 +392,9 @@ Bool ATAPIReadBlks2(CBlkDev *bd,F64 timeout,U8 *buf,
    unlock=BlkDevLock(bd);
  if (ATAPIWaitReady(bd,timeout)) {
    if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
    else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
    OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
    OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
    ATACmd(bd,ATA_PACKET);
@@ -421,8 +421,8 @@ U0 ATAPIReadBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
      blk2=0;
    else
      blk2=FloorU64(blk-bd->max_reads,spc);
-    if (blk2+l2>dv->size)
-      l2=dv->size-blk2;
+    if (blk2+l2>dv->size+dv->drv_offset)
+      l2=dv->size+dv->drv_offset-blk2;
    n=(l2+spc-1)/spc;

    retry=4;
@@ -465,7 +465,7 @@ U0 ATAWriteBlks(CBlkDev *bd,U8 *buf, I64 blk, I64 cnt)
  F64 timeout;
  Bool unlock=BlkDevLock(bd);
 retry:
-  ATABlkSelect(bd,blk,cnt);
+  ATABlkSel(bd,blk,cnt);
  if (bd->flags&BDF_EXT_SIZE)
    ATACmd(bd,ATA_WRITE_MULTI_EXT);
  else
@@ -505,9 +505,9 @@ Bool ATAPISync(CBlkDev *bd)
    okay=FALSE;
  else {
    if (bd->flags & BDF_EXT_SIZE)
-      OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
    else
-      OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+      OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
    OutU8(bd->base0+ATAR0_LCYL,0);
    OutU8(bd->base0+ATAR0_HCYL,0);
    ATACmd(bd,ATA_PACKET);
@@ -522,9 +522,9 @@ U0 ATAPIClose(CBlkDev *bd,I64 close_field=0x200,I64 track=0)
 {//0x200 CD/DVD part 1
 // 0x300    DVD part 2
  if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
  OutU8(bd->base0+ATAR0_LCYL,0);
  OutU8(bd->base0+ATAR0_HCYL,0);
  ATACmd(bd,ATA_PACKET);
@@ -543,9 +543,9 @@ U0 ATAPIWriteBlks(CBlkDev *bd,U8 *buf, I64 native_blk, I64 cnt)
  OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
  OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
  if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
  OutU8(bd->base0+ATAR0_CMD,ATA_PACKET);
  ATAPIWritePktWord(bd,0,0x0400,native_blk.u16[1],native_blk,cnt.u16[1],cnt,0);
  bd->flags|=BDF_LAST_WAS_WRITE;
@@ -554,9 +554,9 @@ U0 ATAPIWriteBlks(CBlkDev *bd,U8 *buf, I64 native_blk, I64 cnt)
  ATAPISeek(bd,native_blk);

  if (bd->flags & BDF_EXT_SIZE)
-    OutU8(bd->base0+ATAR0_SELECT,0xEF|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xEF|bd->unit<<4);
  else
-    OutU8(bd->base0+ATAR0_SELECT,0xE0|bd->unit<<4);
+    OutU8(bd->base0+ATAR0_SEL,0xE0|bd->unit<<4);
  OutU8(bd->base0+ATAR0_LCYL,bd->blk_size);
  OutU8(bd->base0+ATAR0_HCYL,bd->blk_size.u8[1]);
  ATACmd(bd,ATA_PACKET);
@@ -1,6 +1,6 @@
 Bool BootDVDProve(CBlkDev *bd)
 {
-  CKernel *img=CAlloc(DVD_BLK_SIZE);
+  U8 *img=CAlloc(DVD_BLK_SIZE);
  I64 i;
  Bool res=FALSE;
  "Port: %04X,%04X Unit: %02X  ",bd->base0,bd->base1,bd->unit;
@@ -9,8 +9,9 @@ Bool BootDVDProve(CBlkDev *bd)
    if (ATAPIStartStop(bd,tS+5.0,TRUE)) {
      " Started";
      for (i=0;i<2;i++) {//Retry
-	if (ATAPIReadBlks2(bd,tS+7.0,img,sys_boot_src.u16[1],1,FALSE)) {
-	  if (img->compile_time==sys_compile_time) {
+	if (ATAPIReadBlks2(bd,tS+7.0,img,sys_boot_blk,1,FALSE)) {
+	  if ((img+sys_boot_src.u16[1]<<BLK_SIZE_BITS)(CKernel *)
+		->compile_time==sys_compile_time) {
 	    " Found";
 	    return TRUE;
 	  } else
@@ -201,13 +202,12 @@ CATARep *ATARepFind(CATARep *haystack_root,I64 needle_num)
  return NULL;
 }

-CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,
-		CATARep **_ata_drv,CATARep **_atapi_drv)
+CATARep *ATAIDDrvs(CATARep *root,CATARep **_ata_drv,CATARep **_atapi_drv)
 {//This is for when trying to sort-out main hard drives and CD/DVD drives.
  CATARep *res=NULL,*tempha=root,*ata_drv=NULL,*atapi_drv=NULL;
  CBlkDev *bd;
  Bool was_silent=Silent;
-  bd=Let2BlkDev(_sys_boot_drv,FALSE);
+  bd=Let2BlkDev(':',FALSE);
  Silent(was_silent);
  while (tempha) {
    if (!res && bd && bd->type==tempha->type) {
@@ -258,7 +258,7 @@ I64 AutoMountIDE()
  I64 res=0;
  CATARep *root=NULL,*ata_drv=NULL,*atapi_drv=NULL,*tempha;
  ATARep(FALSE,TRUE,&root);
-  ATAIDDrvs(root,blkdev.boot_drv_let,&ata_drv,&atapi_drv);
+  ATAIDDrvs(root,&ata_drv,&atapi_drv);
  if (ata_drv && ATAMount(blkdev.first_hd_drv_let,BDT_ATA,
 	ata_drv->base0,ata_drv->base1,ata_drv->unit))
    res++;
@@ -5,6 +5,9 @@ U0 BlkDevLockFwdingSet(CBlkDev *bd)
  switch (bd->type) {
    case BDT_RAM:
      break;
+    case BDT_FILE:
+      bd->lock_fwding=Let2BlkDev(*bd->file_dsk_name);
+      break;
    case BDT_ATA:
    case BDT_ATAPI:
      for (i=0;i<NUM_BLKDEVS;i++) {
@@ -33,9 +36,11 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
  else
    dv=DrvNextFree(bd->first_drv_let+res);
  dv->bd=bd;
-  dv->size=bd->max_blk+1;
+  dv->drv_offset=bd->drv_offset;
+  dv->size=bd->max_blk+1-bd->drv_offset;
  switch (bd->type) {
    case BDT_RAM:
+    case BDT_FILE:
      dv->dv_signature=DRV_SIGNATURE_VAL;
      dv->fs_type=FSt_REDSEA;
 //This is to force creation of a RAM
@@ -60,7 +65,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	  dv->dv_signature=DRV_SIGNATURE_VAL;
 	  res++;
 	  dv->fs_type=FSt_REDSEA;
-	  dv->size=bd->max_blk+1;
+	  dv->size=bd->max_blk+1-bd->drv_offset;
 //The following read is a test read.
 	  //if it hangs, the drive is not supported.
 	  ATAReadBlks(bd,&mbr,0,1);
@@ -80,7 +85,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	      else
 		dv=DrvNextFree(bd->first_drv_let+res);
 	      dv->bd=bd;
-	      dv->base_offset=mbr.p[i].offset+offset;
+	      dv->drv_offset=mbr.p[i].offset+offset;
 	      dv->size	=mbr.p[i].size;
 	      switch (mbr.p[i].type) {
 		case MBR_PT_REDSEA:
@@ -95,7 +100,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 		case MBR_PT_FAT32d:
 		case MBR_PT_FAT32e:
 		case MBR_PT_FAT32f:
-		  ATAReadBlks(bd,&br,dv->base_offset,1);
+		  ATAReadBlks(bd,&br,dv->drv_offset,1);
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
 		  res++;
 		  if (br.signature==MBR_PT_REDSEA) {
@@ -122,6 +127,8 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	      }
 	    }
 	  }
+	  if (Let2BlkDevType(bd->first_drv_let+res)!=bd->type)
+	    break;
 	  if (j<0)
 	    break;
 	  if (!mbr.p[j].offset)
@@ -138,7 +145,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
      dv->dv_signature=DRV_SIGNATURE_VAL;
      res++;
      dv->fs_type=FSt_ISO9660; //Start with this
-      dv->size =0;
+      dv->size=0;
      break;
  }
  if (res)
@@ -220,5 +227,4 @@ U0 BlkDevsInitAll()
    StreamDoc(kernel_cfg->add_dev);
    StreamPrint("#exe {Option(OPTf_WARN_PAREN,ON);}");
  };
-  DrvRep;
 }
@@ -37,10 +37,9 @@ Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
  try {
    unlock=DrvLock(dv);
    BlkDevInit(bd);
-    if (dv->base_offset && blk<dv->base_offset ||
-	  blk+cnt>dv->base_offset+dv->size)
+    if (dv->drv_offset && blk<dv->drv_offset ||
+	  blk+cnt>dv->drv_offset+dv->size)
      throw('Drv');
-
    if (bd->flags & BDF_READ_CACHE)
      RCache(dv,&buf,&blk,&cnt);
    if (cnt>0) {
@@ -48,6 +47,9 @@ Bool RBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
 	case BDT_RAM:
 	  MemCpy(buf,bd->RAM_dsk+blk<<BLK_SIZE_BITS,cnt<<BLK_SIZE_BITS);
 	  break;
+	case BDT_FILE:
+	  FRBlks(bd->file_dsk,buf,blk,cnt);
+	  break;
 	case BDT_ATA:
 	case BDT_ATAPI:
 	  res=ATARBlks(dv,buf,blk,cnt);
@@ -76,14 +78,17 @@ Bool WBlks(CDrv *dv,U8 *buf, I64 blk, I64 cnt)
    BlkDevInit(bd);
    if (bd->flags&BDF_READ_ONLY && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
      throw('BlkDev');
-    if (dv->base_offset && blk<dv->base_offset ||
-	  blk+cnt>dv->base_offset+dv->size)
+    if (dv->drv_offset && blk<dv->drv_offset ||
+	  blk+cnt>dv->drv_offset+dv->size)
      throw('Drv');
    if (cnt>0) {
      switch (bd->type) {
 	case BDT_RAM:
 	  MemCpy(bd->RAM_dsk+blk<<BLK_SIZE_BITS,buf,cnt<<BLK_SIZE_BITS);
 	  break;
+	case BDT_FILE:
+	  FWBlks(bd->file_dsk,buf,blk,cnt);
+	  break;
 	case BDT_ATA:
 	case BDT_ATAPI:
 	  res=ATAWBlks(dv,buf,blk,cnt);
@@ -30,19 +30,39 @@ Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE)

 Bool BlkDevInit(CBlkDev *bd)
 {
+  CDirEntry de;
+  U8 buf[STR_LEN];
  CDrv *dv=Let2Drv(bd->first_drv_let);
-  Bool res=FALSE;
+  Bool res=FALSE,invalid=FALSE;
  if (!LBts(&bd->flags,BDf_INITIALIZED)) {
    bd->flags|=BDF_INIT_IN_PROGRESS;
    switch (bd->type) {
-      case BDT_RAM:
-	if (!bd->RAM_dsk) {
-	  bd->RAM_dsk=AMAlloc((bd->max_blk+1)<<BLK_SIZE_BITS);
-	  bd->max_blk=MSize(bd->RAM_dsk)>>BLK_SIZE_BITS-1;
-	}
+      start:
+	case BDT_RAM:
+	  if (!bd->RAM_dsk) {
+	    bd->RAM_dsk=AMAlloc((bd->max_blk+1)<<BLK_SIZE_BITS);
+	    bd->max_blk=MSize(bd->RAM_dsk)>>BLK_SIZE_BITS-1;
+	  }
+	  break;
+	case BDT_FILE:
+	  if (!bd->file_dsk_name) {
+	    StrPrint(buf,"%C:/Drv%C.DRV.C",
+		  blkdev.boot_drv_let,bd->first_drv_let);
+	    bd->file_dsk_name=AStrNew(buf);
+	  }
+	  if (FileFind(bd->file_dsk_name,&de,FUF_JUST_FILES))
+	    bd->max_blk=de.size>>BLK_SIZE_BITS-1;
+	  else {
+	    invalid=TRUE;
+	    if (bd->max_blk<7)
+	      bd->max_blk=7;
+	  }
+	  bd->file_dsk=FOpen(bd->file_dsk_name,"wc+",bd->max_blk+1);
+	  break;
+      end:
 	dv->fs_type=FSt_REDSEA;
-	dv->size=bd->max_blk+1;
-	if (RedSeaDrvValidate(bd->first_drv_let))
+	dv->size=bd->max_blk+1-bd->drv_offset;
+	if (!invalid && RedSeaDrvValidate(bd->first_drv_let))
 	  RedSeaDrvInit(dv);
 	else
 	  RedSeaFmt(bd->first_drv_let);
@@ -89,6 +109,8 @@ CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
 {//Locate free slot for new BlkDev, like during $LK,"Mount",A="MN:Mount"$().
  I64 i=0;
  CBlkDev *res;
+  if (Let2BlkDevType(first_drv_let)!=type)
+    throw('BlkDev');
  do {
    res=&blkdev.blkdevs[i];
    if (res->bd_signature!=BD_SIGNATURE_VAL) {
@@ -116,6 +138,14 @@ CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
  return NULL; //never gets here
 }

+U0 BlkDevDel(CBlkDev *bd)
+{//Delete BlkDev
+  FClose(bd->file_dsk);
+  Free(bd->file_dsk_name);
+  Free(bd->dev_id_record);
+  MemSet(bd,0,sizeof(CBlkDev));
+}
+
 CBlkDev *BlkDevChk(CBlkDev *bd,Bool except=TRUE)
 {//Check for valid BlkDev. Throw exception.
  if (!bd || bd->bd_signature!=BD_SIGNATURE_VAL ||
@@ -1,7 +1,75 @@
+//ISO1 is ISO9660
+//ISO2 is ISO13490
+//ISO3 is ISO13346
+
+Bool ISODrvInit(CDrv *dv,I64 blk)
+{
+  CBlkDev *bd=dv->bd;
+  I64 spc=bd->blk_size>>BLK_SIZE_BITS,i=blk/spc,drv_offset=0;
+  CISO1PriDesc *iso=MAlloc(bd->blk_size);
+  CISO1DirEntry *de;
+  Bool unlock,res=FALSE;
+  U8 buf[8];
+
+  try {
+    unlock=DrvLock(dv);
+    dv->fs_type=FSt_ISO9660; //default
+    dv->spc=spc;
+    dv->drv_offset=bd->drv_offset=dv->data_area=dv->root_cluster=dv->size=0;
+    while (TRUE) {
+      dv->size=MaxI64(dv->size,(i+1)*spc);
+      RBlks(dv,iso,i*spc,spc);
+      buf[0](U32)=iso->id[0](U32);
+      buf[4](U16)=iso->id[4](U8);
+      switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",
+	    LMF_EXACT)) {
+	case 0:
+	  switch (iso->type) {
+	    case ISO1T_BOOT_RECORD:
+	      drv_offset+=(2*DVD_BLK_SIZE+DVD_BLK_SIZE)/BLK_SIZE;
+	      break;
+	    case ISO1T_SUPPLEMENTARY_DESC:
+	      de=&iso->root_dir_record;
+	      dv->root_cluster=de->loc.little;
+	      dv->size=iso->vol_space_size.little*bd->blk_size>>BLK_SIZE_BITS;
+	      if (!StrCmp(iso->publisher_id,"TempleOS RedSea")) {
+		dv->fs_type=FSt_REDSEA;
+		bd->drv_offset=dv->drv_offset=19<<2+drv_offset;
+		bd->max_blk=dv->size-1;
+		dv->size-=bd->drv_offset;
+		RedSeaDrvInit(dv);
+	      }
+	      res=TRUE;
+	      goto ipi_done;
+	    case ISO1T_TERMINATOR:
+	      throw('Drv');
+	  }
+	  break;
+	default: //Its normal for ISO13346 to read NULL blk as terminator
+	  PrintErr("File System Not Supported\n");
+	  throw('Drv');
+      }
+      i++;
+    }
+ipi_done:
+    Free(iso);
+    if (unlock)
+      DrvUnlock(dv);
+  } catch {
+    dv->fs_type=FSt_ISO9660;
+    dv->spc=spc;
+    dv->drv_offset=bd->drv_offset=dv->data_area=dv->root_cluster=0;
+    Free(iso);
+    if (unlock)
+      DrvUnlock(dv);
+  }
+  return res;
+}
+
 U0 DVDImageRead(U8 dvd_drv_let,U8 *out_name)
 {//Read entire CD/DVD image into ISO file.
-  CBlkDev *bd=Let2BlkDev(dvd_drv_let);
  CDrv *dv=Let2Drv(dvd_drv_let);
+  CBlkDev *bd=dv->bd;
  U8 *buf=MAlloc(COPY_BUF_BLKS<<BLK_SIZE_BITS),
 	*out_name2=DftExt(out_name,"ISO");
  CFile *f=FOpen(out_name2,"w");
@@ -55,8 +55,7 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
 	f->flags&=~FF_NEW_FILE;
      }
      DirContextDel(dirc);
-      if (!contiguous || cnt>0)
-	return f;
+      return f;
    }
  } else {
    if (FileFind(full_name,&f->de,FUF_JUST_FILES)) {
@@ -160,9 +160,9 @@ CDirEntry *DirFilesFlatten(CDirEntry *tempde,CDirEntry **_res,I64 fuf_flags)
  return _res;
 }

-U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE)
+U0 PutFileLink(U8 *filename,U8 *full_name=NULL,I64 line=0,Bool plain_text=FALSE)
 {//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT"$ file,line link to StdOut, $LK,"DocPut",A="MN:DocPut"$.
-  U8 *buf;
+  U8 *st;
  if (!filename) return;
  if (IsRaw) {
    if (line)
@@ -177,32 +177,38 @@ U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE)
      else
 	"$$LK,\"%s\",A=\"AI:%s\"$$",filename+3,filename+3;
    } else {
-      buf=FileNameAbs(filename);
+      if (!full_name)
+	full_name=st=FileNameAbs(filename);
+      else
+	st=NULL;
      if (plain_text) {
 	if (line)
-	  "$$LK,\"%s,%04d\",A=\"PL:%s,%d\"$$",filename,line,buf,line;
+	  "$$LK,\"%s,%04d\",A=\"PL:%s,%d\"$$",filename,line,full_name,line;
 	else
-	  "$$LK,\"%s\",A=\"PI:%s\"$$",filename,buf;
+	  "$$LK,\"%s\",A=\"PI:%s\"$$",filename,full_name;
      } else {
 	if (line)
-	  "$$LK,\"%s,%04d\",A=\"FL:%s,%d\"$$",filename,line,buf,line;
+	  "$$LK,\"%s,%04d\",A=\"FL:%s,%d\"$$",filename,line,full_name,line;
 	else
-	  "$$LK,\"%s\",A=\"FI:%s\"$$",filename,buf;
+	  "$$LK,\"%s\",A=\"FI:%s\"$$",filename,full_name;
      }
-      Free(buf);
+      Free(st);
    }
  }
 }

-U0 PutDirLink(U8 *dirname)
+U0 PutDirLink(U8 *dirname,U8 *full_name=NULL)
 {//Put $LK,"DolDoc",A="FI:::/Doc/DolDocOverview.TXT"$ dir macro to StdOut, $LK,"DocPut",A="MN:DocPut"$.
-  U8 *buf;
+  U8 *st;
  if (!dirname) return;
  if (IsRaw)
    "%s",dirname;
  else {
-    buf=DirNameAbs(dirname);
-    "$$MA,T=\"%s\",LM=\"Cd(\\\"%s\\\");Dir;\n\"$$",dirname,buf;
-    Free(buf);
+    if (!full_name)
+      full_name=st=DirNameAbs(dirname);
+    else
+      st=NULL;
+    "$$MA,T=\"%s\",LM=\"Cd(\\\"%s\\\");Dir;\n\"$$",dirname,full_name;
+    Free(st);
  }
 }
@@ -1,3 +1,11 @@
+U0 HomeSet(U8 *dirname)
+{//Change home directory.
+  dirname=DirNameAbs(dirname);
+  Free(blkdev.home_dir);
+  blkdev.home_dir=AStrNew(dirname);
+  Free(dirname);
+}
+
 Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
 {//Change directory. Optionally, make directories, too.
  I64 maxlen,cur_dir_cluster=0;
@@ -5,7 +13,7 @@ Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
  CDrv *dv;
  Bool res=TRUE;
  if (!dirname)
-    dirname="::/Home";
+    dirname="~";
  else if (!*dirname)
    return TRUE;
  if (dirname[1]==':') {
@@ -36,6 +44,12 @@ Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
      StrLastRem(new_cur_dir,"/");
      if (!*new_cur_dir)
 	StrCpy(new_cur_dir,"/");
+    } else if (!StrCmp(buf,"~")) {
+      Free(new_cur_dir);
+      new_cur_dir=MAlloc(StrLen(blkdev.home_dir+2)+1+StrLen(chg_to_buf)+1);
+      StrCpy(new_cur_dir,blkdev.home_dir+2);
+      if (Fs->cur_dv!=Let2Drv('~') && !Drv('~'))
+	return FALSE;
    } else if (StrCmp(buf,".") && *buf) {
      dv=Fs->cur_dv;
      cur_dir_cluster=Name2DirCluster(dv,new_cur_dir);
@@ -99,6 +113,11 @@ I64 Dir(U8 *files_find_mask,Bool full)
    PrintErr("Invalid Drive\n");
  else {
    if (tempde1) {
+      Free(st);
+      st=MAllocIdent(tempde1->full_name);
+      StrLastRem(st,"/");
+      if (!st[2])
+	StrCpy(st+2,"/");
 //Find max columns
      tempde2=tempde1;
      while (tempde2) {
@@ -129,9 +148,9 @@ I64 Dir(U8 *files_find_mask,Bool full)
 		csize,tempde1->size;
 	}
 	if (tempde1->attr & RS_ATTR_DIR)
-	  PutDirLink(tempde1->name);
+	  PutDirLink(tempde1->name,tempde1->full_name);
 	else
-	  PutFileLink(tempde1->name);
+	  PutFileLink(tempde1->name,tempde1->full_name);
 	'\n';
 	DirEntryDel(tempde1);
 	tempde1=tempde2;
@@ -143,8 +162,9 @@ I64 Dir(U8 *files_find_mask,Bool full)
  return res;
 }

-Bool MkDir(U8 *filename)
+Bool MkDir(U8 *filename,I64 entry_cnt=0)
 {//Make directory. $LK,"Cd",A="MN:Cd"$() can also make directories.
+//entry_cnt is for preallocating dir blks, leave it zero if you like.
  U8 *name;
  CDirContext *dirc;
  Bool res=FALSE;
@@ -160,10 +180,10 @@ Bool MkDir(U8 *filename)
 	      SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
 	switch (dirc->dv->fs_type) {
 	  case FSt_REDSEA:
-	    res=RedSeaMkDir(dirc->dv,Fs->cur_dir,name);
+	    res=RedSeaMkDir(dirc->dv,Fs->cur_dir,name,entry_cnt);
 	    break;
 	  case FSt_FAT32:
-	    res=FAT32MkDir(dirc->dv,Fs->cur_dir,name);
+	    res=FAT32MkDir(dirc->dv,Fs->cur_dir,name,entry_cnt);
 	    break;
 	  case FSt_ISO9660:
 	    PrintErr("Not Writable\n");
@@ -34,6 +34,8 @@ CDirContext *DirContextNew(U8 *_mask,Bool make_mask=FALSE,
      valid=FALSE;
    mask+=2;
  }
+  if (*mask=='~' && Fs->cur_dv!=Let2Drv('~') && !Drv('~'))
+    valid=FALSE;
  dirc->dv=Fs->cur_dv;
  DrvChk(dirc->dv);
  buf=MAlloc(mask_len+2);
@@ -62,6 +62,15 @@ CDrv *DrvNextFree(U8 first_drv_let='C')
  return NULL; //never gets here
 }

+U0 DrvDel(CDrv *dv)
+{//Delete drv
+  if (dv->fs_type==FSt_REDSEA && dv->next_free)
+    RedSeaFreeFreeLst(dv);
+  Free(dv->cur_fat_blk);
+  Free(dv->fis);
+  MemSet(dv,0,sizeof(CDrv));
+}
+
 U0 DrvFATBlkAlloc(CDrv *dv)
 {
  DrvChk(dv);
@@ -72,7 +81,7 @@ U0 DrvFATBlkAlloc(CDrv *dv)
  RBlks(dv,dv->cur_fat_blk,dv->fat1,1);
 }

-U0 DrvFATBlkClean(CDrv *dv,I64 fat_select=3)
+U0 DrvFATBlkClean(CDrv *dv,I64 fat_sel=3)
 {
  if ((dv->fs_type==FSt_FAT32 || dv->fs_type==FSt_REDSEA) &&
       Bt(&dv->fat_blk_dirty,0)) {
@@ -80,9 +89,9 @@ U0 DrvFATBlkClean(CDrv *dv,I64 fat_select=3)
      WBlks(dv,dv->cur_fat_blk,dv->fat1+dv->cur_fat_blk_num,1);
      LBtr(&dv->fat_blk_dirty,0);
    } else {
-      if (fat_select==3 || !fat_select)
+      if (fat_sel==3 || !fat_sel)
 	WBlks(dv,dv->cur_fat_blk,dv->fat1+dv->cur_fat_blk_num,1);
-      if (fat_select==3 || fat_select==1) {
+      if (fat_sel==3 || fat_sel==1) {
 	WBlks(dv,dv->cur_fat_blk,dv->fat2+dv->cur_fat_blk_num,1);
 	LBtr(&dv->fat_blk_dirty,0);
      }
@@ -90,7 +99,7 @@ U0 DrvFATBlkClean(CDrv *dv,I64 fat_select=3)
  }
 }

-U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_select=3)
+U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_sel=3)
 {
  I64 fat_blk_num;
  if (c==INVALID_CLUSTER)
@@ -106,9 +115,9 @@ U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_select=3)
      throw('Drv');
  }
  if (fat_blk_num!=dv->cur_fat_blk_num) {
-    DrvFATBlkClean(dv,fat_select);
+    DrvFATBlkClean(dv,fat_sel);
    dv->cur_fat_blk_num=fat_blk_num;
-    if (fat_select==3 || !fat_select)
+    if (fat_sel==3 || !fat_sel)
      RBlks(dv,dv->cur_fat_blk,dv->fat1+dv->cur_fat_blk_num,1);
    else
      RBlks(dv,dv->cur_fat_blk,dv->fat2+dv->cur_fat_blk_num,1);
@@ -139,8 +148,10 @@ I64 Let2BlkDevType(U8 drv_let)
  drv_let=ToUpper(drv_let);
  if ('A'<=drv_let<='B')
    return BDT_RAM;
-  if ('C'<=drv_let<='S')
+  if ('C'<=drv_let<='L')
    return BDT_ATA;
+  if ('M'<=drv_let<='S')
+    return BDT_FILE;
  if ('T'<=drv_let<='Z')
    return BDT_ATAPI;
  return BDT_NULL;
@@ -154,6 +165,8 @@ CDrv *Let2Drv(U8 drv_let=0,Bool except=TRUE)
  else {
    if (drv_let==':')
      drv_let=blkdev.boot_drv_let;
+    else if (drv_let=='~')
+      drv_let=*blkdev.home_dir;
    drv_let=ToUpper(drv_let);
    if (!('A'<=drv_let<='Z')) {
      if (except)
@@ -188,7 +201,7 @@ U0 DskCacheInvalidate(CDrv *dv)
    BlkDevInit(bd);
    if (bd->flags & BDF_READ_CACHE)
      DskCacheInvalidate2(dv);
-    if (dv->fs_type==FSt_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
+    if (bd->type==BDT_ATAPI && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
      ISODrvInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
    if (unlock)
      DrvUnlock(dv);
@@ -228,7 +241,7 @@ Bool Drv(U8 drv_let)
  if (dv!=Fs->cur_dv) {
    if (bd->flags & BDF_REMOVABLE && !(bd->flags & BDF_INITIALIZED))
      ChgDsk(Drv2Let(dv));
-    if (bd->type==BDT_RAM)
+    if (bd->type==BDT_RAM || bd->type=BDT_FILE)
      BlkDevInit(bd);
  }
  Fs->cur_dv=dv;
@@ -275,7 +288,7 @@ U8 *DrvModelNum(U8 drv_let=0)
  return res;
 }

-U8 blkdev_text_attr[BDT_NUM_TYPES]={BLACK,LTCYAN,WHITE,LTBLUE};
+U8 blkdev_text_attr[BDT_NUM_TYPES]={BLACK,LTCYAN,WHITE,LTGREEN,LTBLUE};
 U8 drv_text_attr[3]={BLACK,BLUE,RED};

 U8 DrvTextAttrGet(U8 drv_let=0)
@@ -284,6 +297,8 @@ U8 DrvTextAttrGet(U8 drv_let=0)
    drv_let=Drv2Let(Fs->cur_dv);
  else if (drv_let==':')
    drv_let=blkdev.boot_drv_let;
+  else if (drv_let=='~')
+    drv_let=*blkdev.home_dir;
  drv_let=ToUpper(drv_let);
  if ('A'<=drv_let<='Z')
    return blkdev_text_attr[Let2BlkDevType(drv_let)]<<4|
@@ -298,7 +313,7 @@ U0 DrvRep()
  CBlkDev *bd;
  I64 ch,i,drv_let,attr;
  U8 *st;
-  "\nDefined Drives:\n\n";
+  "\nDefined Drives:\n";
  for (i=0,dv=blkdev.drvs;i<NUM_DRVS;i++,dv++) {
    if (dv->dv_signature==DRV_SIGNATURE_VAL) {
      bd=dv->bd;
@@ -321,9 +336,8 @@ U0 DrvRep()
 	"   Serial#:%s\n",st;
 	Free(st);
      }
-      "   %016X-%016X\n$$FG$$$$BG$$",
-	    dv->base_offset,dv->base_offset+dv->size-1;
-      dv->base_offset,dv->base_offset+dv->size-1;
+      "   %016X-%016X\n$$FG$$$$BG$$",dv->drv_offset,dv->drv_offset+dv->size-1;
    }
  }
+  "Home Dir:\"%s\"\n",blkdev.home_dir;
 }
@@ -23,16 +23,13 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
      if (dirc=DirContextNew(curname)) {
 	switch (dirc->dv->fs_type) {
 	  case FSt_REDSEA:
-	    res=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		  &size,&attr);
+	    res=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	    break;
 	  case FSt_FAT32:
-	    res=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		  &size,&attr);
+	    res=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	    break;
 	  case FSt_ISO9660:
-	    res=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		  &size,&attr);
+	    res=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	    break;
 	  default:
 	    PrintErr("File System Not Supported\n");
@@ -52,16 +49,13 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
 	  Cd("..");
 	  switch (Fs->cur_dv->fs_type) {
 	    case FSt_REDSEA:
-	      res=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		    &size,&attr);
+	      res=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	      break;
 	    case FSt_FAT32:
-	      res=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		    &size,&attr);
+	      res=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	      break;
 	    case FSt_ISO9660:
-	      res=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
-		    &size,&attr);
+	      res=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,&size,&attr);
 	      break;
 	    default:
 	      PrintErr("File System Not Supported\n");
@@ -75,8 +69,7 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
      PrintErr("File not found.\n");
    }
    if (res && attr & RS_ATTR_RESIDENT)
-      HashGenericAdd(curname,HTT_FILE,
-	    AMAllocIdent(res),size,0,adam_task);
+      HashGenericAdd(curname,HTT_FILE,AMAllocIdent(res),size,0,adam_task);
  }
  if (res && attr & RS_ATTR_COMPRESSED) {
    arc=res;
@@ -108,12 +101,10 @@ I64 FileWrite(U8 *filename,U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0)
    if (!cdt) cdt=Now;
    switch (dirc->dv->fs_type) {
      case FSt_REDSEA:
-	c=RedSeaFileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
-	      size,cdt,attr);
+	c=RedSeaFileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,size,cdt,attr);
 	break;
      case FSt_FAT32:
-	c=FAT32FileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
-	      size,cdt,attr);
+	c=FAT32FileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,size,cdt,attr);
 	break;
      case FSt_ISO9660:
 	PrintErr("Not Writable\n");
@@ -65,6 +65,17 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=FSt_FAT32)
    return;
  }
  switch (type) {
+    case FSt_FAT32:
+      if (dv->bd->type==BDT_ATA) {
+	Silent;
+	Drv(drv_let);
+	Silent(old_silent);
+	FAT32Fmt(drv_let,quick);
+	DskCacheInvalidate(Let2Drv(drv_let));
+	Drv(drv_let);
+	break;
+      }
+      "Using RedSea File System.\n";
    case FSt_REDSEA:
      Silent;
      Drv(drv_let);
@@ -73,14 +84,6 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=FSt_FAT32)
      DskCacheInvalidate(Let2Drv(drv_let));
      Drv(drv_let);
      break;
-    case FSt_FAT32:
-      Silent;
-      Drv(drv_let);
-      Silent(old_silent);
-      FAT32Fmt(drv_let,quick);
-      DskCacheInvalidate(Let2Drv(drv_let));
-      Drv(drv_let);
-      break;
    case FSt_ISO9660:
      PrintErr("Not Writable\n");
      break;
@@ -60,7 +60,7 @@ Bool FilesFindMatch(U8 *_test_name,U8 *files_find_mask,I64 fuf_flags=0)
    else
      ptr=test_name2;
    if (*mask2) {
-      if (*mask2=='~') {
+      if (*mask2=='!') {
 	if (WildMatch(ptr,mask2+1)) {
 	  res=FALSE;
 	  break;
@@ -115,6 +115,8 @@ U8 *DirNameAbs(U8 *_dirname)
  if (*dirname && dirname[1]==':') {
    if (*dirname==':')
      *drv=blkdev.boot_drv_let;
+    else if (*dirname=='~')
+      *drv=*blkdev.home_dir;
    else
      *drv=*dirname;
    dirname=dirname+2;
@@ -139,9 +141,13 @@ U8 *DirNameAbs(U8 *_dirname)
      StrLastRem(buf3,"/");
      if (!*buf3)
 	StrCpy(buf3,"/");
-    } else if (!StrCmp(buf4,".")) {
-      ;
-    } else if (*buf4) {
+    } else if (!StrCmp(buf4,"~")) {
+      Free(buf3);
+      buf3=MAlloc(StrLen(blkdev.home_dir+2)+1+StrLen(buf2)+1);
+      StrCpy(buf3,blkdev.home_dir+2);
+      *drv=*blkdev.home_dir;
+    } else if (!StrCmp(buf4,"."));
+    else if (*buf4) {
      if (StrCmp(buf3,"/"))
 	CatPrint(buf3,"/");
      CatPrint(buf3,buf4);
@@ -265,7 +271,7 @@ U8 *ToggleZorNotZ(U8 *name)

 U8 *FileNameTempTxt()
 {//Make pretty-safe temp filename in home dir.
-  return MStrPrint("::/Home/SysTemp%X.TXT.Z",GetTSC>>8&0xFFFFFFFF);
+  return MStrPrint("~/SysTemp%X.TXT.Z",GetTSC>>8&0xFFFFFFFF);
 }

 U8 *CurDir(CTask *task=NULL,CTask *mem_task=NULL)
@@ -26,9 +26,9 @@ U0 FAT32DrvInit(CDrv *dv)
  try {
    unlock=DrvLock(dv);
    dv->fs_type=FSt_FAT32;
-    RBlks(dv,&br32,dv->base_offset,1);
-    dv->file_system_info_sect=dv->base_offset+br32.file_system_info_sect;
-    dv->fat1=dv->base_offset+br32.reserved_sects;
+    RBlks(dv,&br32,dv->drv_offset,1);
+    dv->file_system_info_sect=dv->drv_offset+br32.file_system_info_sect;
+    dv->fat1=dv->drv_offset+br32.reserved_sects;
    dv->fat2=dv->fat1+br32.sects_per_fat;
    dv->data_area=dv->fat2+br32.sects_per_fat
 	  -2*br32.sects_per_cluster; //Starts at Cluster 2
@@ -50,7 +50,7 @@ Bool FAT32DrvValidate(U8 drv_let)
  CDrv *dv;
  CFAT32Boot br;
  if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_FAT32 &&
-	RBlks(dv,&br,dv->base_offset,1) && br.signature==0xAA55 &&
+	RBlks(dv,&br,dv->drv_offset,1) && br.signature==0xAA55 &&
 	br.sects==dv->size)
    return TRUE;
  else
@@ -111,14 +111,14 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
      i=br->reserved_sects+2*l+4*br->sects_per_cluster;
    else
      i=dv->size;
-    WZeroBlks(dv,dv->base_offset,i);
+    WZeroBlks(dv,dv->drv_offset,i);

-    WBlks(dv,fis,dv->base_offset+br->file_system_info_sect,1);
-    WBlks(dv,br,dv->base_offset,1);
+    WBlks(dv,fis,dv->drv_offset+br->file_system_info_sect,1);
+    WBlks(dv,br,dv->drv_offset,1);
    FAT32DrvInit(dv);
    ClustersAlloc(dv,0,1,FALSE); //Alloc #1
    br->root_cluster=ClustersAlloc(dv,0,1,FALSE);
-    WBlks(dv,br,dv->base_offset,1);
+    WBlks(dv,br,dv->drv_offset,1);
    FAT32DrvInit(dv);
    DrvUnlock(dv);
  } catch
@@ -462,7 +462,7 @@ I64 FAT32AllocClusters(CDrv *dv,I64 c,I64 cnt)
  try {
    unlock_break=BreakLock;
    unlock=DrvLock(dv);
-    l=(dv->size+dv->base_offset-dv->data_area)/dv->spc-1;
+    l=(dv->size+dv->drv_offset-dv->data_area)/dv->spc-1;
    j=dv->fis->most_recently_alloced;
    while (cnt-->0) {
      while (TRUE) {
@@ -525,7 +525,7 @@ I64 FAT32AllocContiguousClusters(CDrv *dv,I64 cnt)
      i=0;
      cont=TRUE;
      while (cont && i<cnt) {
-	if ((first+i+1)*dv->spc+dv->data_area>dv->size+dv->base_offset)
+	if ((first+i+1)*dv->spc+dv->data_area>dv->size+dv->drv_offset)
 	  throw('Drv');
 	DrvFATBlkSet(dv,first+i);
 	if (dv->cur_fat_blk[(first+i)&(BLK_SIZE/4-1)])
@@ -930,10 +930,11 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,
  return res;
 }

-Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name)
+Bool FAT32MkDir(CDrv *dv,U8 *cur_dir,U8 *name,I64 entry_cnt)
 {
-  I64 size=dv->spc<<BLK_SIZE_BITS,c,
-	cur_dir_cluster=Name2DirCluster(dv,cur_dir);
+  I64 c,cur_dir_cluster=Name2DirCluster(dv,cur_dir),
+//Rough estimate of size
+	size=CeilU64((entry_cnt+2)<<FAT32_ENTRIES_BITS,dv->spc<<BLK_SIZE_BITS);
  U8 *buf=CAlloc(size);
  CDirEntry d_native;
  CFAT32DirEntry *dFAT=buf;
@@ -1,63 +1,3 @@
-//ISO1 is ISO9660
-//ISO2 is ISO13490
-//ISO3 is ISO13346
-
-Bool ISODrvInit(CDrv *dv,I64 blk)
-{
-  CBlkDev *bd=dv->bd;
-  I64 spc=bd->blk_size>>BLK_SIZE_BITS,i=blk/spc;
-  CISO1PriDesc *iso=MAlloc(bd->blk_size);
-  CISO1DirEntry *de;
-  Bool unlock,res=FALSE;
-  U8 buf[8];
-
-  try {
-    unlock=DrvLock(dv);
-    dv->fs_type=FSt_ISO9660; //default
-    dv->spc=spc;
-    dv->base_offset=dv->data_area=dv->root_cluster=dv->size=0;
-    while (TRUE) {
-      dv->size=MaxI64(dv->size,(i+1)*spc);
-      RBlks(dv,iso,i*spc,spc);
-      buf[0](U32)=iso->id[0](U32);
-      buf[4](U16)=iso->id[4](U8);
-      switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",
-	    LMF_EXACT)) {
-	case 0:
-	  dv->fs_type=FSt_ISO9660;
-	  switch (iso->type) {
-	    case ISO1T_SUPPLEMENTARY_DESC:
-	      dv->data_area=0;
-	      de=&iso->root_dir_record;
-	      dv->root_cluster=de->loc.little;
-	      dv->size=iso->vol_space_size.little*bd->blk_size>>BLK_SIZE_BITS;
-	      res=TRUE;
-	      goto ipi_done;
-	    case ISO1T_TERMINATOR:
-	      throw('Drv');
-	  }
-	  break;
-	default: //Its normal for ISO13346 to read NULL blk as terminator
-	  PrintErr("File System Not Supported\n");
-	  throw('Drv');
-      }
-      i++;
-    }
-ipi_done:
-    Free(iso);
-    if (unlock)
-      DrvUnlock(dv);
-  } catch {
-    dv->fs_type=FSt_ISO9660;
-    dv->spc=spc;
-    dv->base_offset=dv->data_area=dv->root_cluster=0;
-    Free(iso);
-    if (unlock)
-      DrvUnlock(dv);
-  }
-  return res;
-}
-
 U0 Date2ISO1(CISO1Date *dst,CDate cdt)
 {
  CDateStruct ds;
@@ -25,7 +25,7 @@ U0 RedSeaFreeLstBuild(CDrv *dv)
 {
  Bool unlock;
  CFreeLst *tempf;
-  I64 i,first=dv->data_area,max_blk=dv->size+dv->base_offset;
+  I64 i,first=dv->data_area,max_blk=dv->size+dv->drv_offset;
  try {
    unlock=DrvLock(dv);
    if (dv->next_free)
@@ -61,16 +61,16 @@ U0 RedSeaDrvInit(CDrv *dv)
  Bool unlock;
  try {
    unlock=DrvLock(dv);
-    RBlks(dv,&br,dv->base_offset,1);
+    RBlks(dv,&br,dv->drv_offset,1);
    if (br.signature!=MBR_PT_REDSEA || br.signature2!=0xAA55)
      throw('Drv');
    dv->fs_type=FSt_REDSEA;
    RedSeaFreeFreeLst(dv);
    dv->spc=1;
    dv->size=br.sects;
-    dv->data_area=dv->base_offset+br.bitmap_sects;
+    dv->data_area=dv->drv_offset+br.bitmap_sects;
    dv->root_cluster=br.root_cluster;
-    dv->fat1=dv->fat2=dv->base_offset+1;
+    dv->fat1=dv->fat2=dv->drv_offset+1;
    DrvFATBlkAlloc(dv);
    if (unlock)
      DrvUnlock(dv);
@@ -84,7 +84,7 @@ Bool RedSeaDrvValidate(U8 drv_let)
  CDrv *dv;
  CRedSeaBoot br;
  if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_REDSEA &&
-	RBlks(dv,&br,dv->base_offset,1) && br.signature==MBR_PT_REDSEA &&
+	RBlks(dv,&br,dv->drv_offset,1) && br.signature==MBR_PT_REDSEA &&
 	br.signature2==0xAA55 && br.sects==dv->size)
    return TRUE;
  else
@@ -97,7 +97,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
  CDirEntry *d_native;
  CRedSeaBoot *br=CAlloc(BLK_SIZE);
  CDrv *dv=Let2Drv(drv_let);
-  I64 i,n;
+  I64 i,n,root_dir_blks;
  try {
    DrvLock(dv);
 //	DrvTypeSet(drv_let,FSt_REDSEA);
@@ -105,7 +105,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
    dv->fs_type=FSt_REDSEA;
    br->signature=MBR_PT_REDSEA;
    br->signature2=0xAA55;
-    br->base_offset=dv->base_offset; //For CD/DVD image copy.
+    br->drv_offset=dv->drv_offset; //For CD/DVD image copy.
    br->sects=dv->size;
    n=(br->sects+BLK_SIZE<<3-1)/BLK_SIZE<<3;
    br->bitmap_sects=n;
@@ -116,21 +116,23 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
      i=n+1;
    else
      i=dv->size;
-    WZeroBlks(dv,dv->base_offset,i);
+    WZeroBlks(dv,dv->drv_offset,i);

-    WBlks(dv,br,dv->base_offset,1);
+    WBlks(dv,br,dv->drv_offset,1);
    RedSeaDrvInit(dv);
    ClustersAlloc(dv,0,1,FALSE);	//Alloc #1
-    br->root_cluster=ClustersAlloc(dv,0,1,FALSE);
-    WBlks(dv,br,dv->base_offset,1);
-    root_dir=CAlloc(BLK_SIZE);
+
+    root_dir_blks=MaxI64(1,dv->bd->init_root_dir_blks);
+    br->root_cluster=ClustersAlloc(dv,0,root_dir_blks,FALSE);
+    WBlks(dv,br,dv->drv_offset,1);
+    root_dir=CAlloc(BLK_SIZE*root_dir_blks);

    d_native=root_dir-offset(CDirEntry.start);

    d_native->attr=RS_ATTR_DIR|RS_ATTR_CONTIGUOUS;
    *d_native->name='.';
    d_native->cluster=br->root_cluster;
-    d_native->size=BLK_SIZE;
+    d_native->size=BLK_SIZE*root_dir_blks;
    d_native->datetime=Now;

    d_native(U8 *)+=CDIR_SIZE;
@@ -141,7 +143,7 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
    d_native->cluster=br->root_cluster;
    d_native->datetime=Now;

-    WBlks(dv,root_dir,br->root_cluster,1);
+    WBlks(dv,root_dir,br->root_cluster,root_dir_blks);
    RedSeaDrvInit(dv);
    DrvUnlock(dv);
  } catch
@@ -389,9 +391,9 @@ Bool RedSeaDirNew(CDrv *dv,U8 *cur_dir,CDirEntry *de,Bool free_old_chain)
 	  WBlks(dv,buf,c,dir_size>>BLK_SIZE_BITS);
 	  if (cur_dir_cluster==dv->root_cluster) {
 	    br=CAlloc(BLK_SIZE);
-	    RBlks(dv,br,dv->base_offset,1);
+	    RBlks(dv,br,dv->drv_offset,1);
 	    br->root_cluster=c;
-	    WBlks(dv,br,dv->base_offset,1);
+	    WBlks(dv,br,dv->drv_offset,1);
 	    Free(br);
 	    dv->root_cluster=c;
 	  } else {
@@ -599,13 +601,14 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,
  return res;
 }

-Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name)
-{
-  I64 size=BLK_SIZE,c,cur_dir_cluster=Name2DirCluster(dv,cur_dir);
+Bool RedSeaMkDir(CDrv *dv,U8 *cur_dir,U8 *name,I64 entry_cnt)
+{//entry_cnt is for preallocating dir blks.
+  I64	c,cur_dir_cluster=Name2DirCluster(dv,cur_dir),
+	size=CeilU64((entry_cnt+3)<<6,BLK_SIZE);
+#assert CDIR_SIZE==64
  U8 *buf=CAlloc(size);
  CDirEntry *d_native=buf-offset(CDirEntry.start);
  Bool unlock_break;
-
  try {
    unlock_break=BreakLock;
    c=FileWrite(name,buf,size,0,RS_ATTR_DIR);
@@ -44,13 +44,13 @@ See also $LK,"GrUpdateScreen",A="MN:GrUpdateScreen"$().
    col=text.raw_col%text.cols;
    if (!Bt(&sys_run_level,RLf_VGA)) { //if text mode
      if (text.raw_flags&RWF_SCROLL && text.raw_col && !row && !col) {
-	MemCpy(VGAM_TEXT,VGAM_TEXT+text.cols,
+	MemCpy(text.vga_text_alias,text.vga_text_alias+text.cols*2,
 	      text.cols*(text.rows-1)*2);
-	MemSet(VGAM_TEXT+text.cols*(text.rows-1)*2,0,text.cols*2);
+	MemSet(text.vga_text_alias+text.cols*(text.rows-1)*2,0,text.cols*2);
 	text.raw_col-=text.cols;
 	row=text.rows-1;
      }
-      ptr=VGAM_TEXT+(row*text.cols+col)*2;
+      ptr=text.vga_text_alias+(row*text.cols+col)*2;
      ptr[0]=ch;
      ptr[1]=BLACK<<4+WHITE;
    } else {
@@ -75,7 +75,7 @@ See also $LK,"GrUpdateScreen",A="MN:GrUpdateScreen"$().
      ptr1+=text.raw_screen_image; //Write to cached image as well
      ptr2=&text.font[ch&255];
      for (i=0;i<FONT_HEIGHT;i++) {
-	*ptr=*ptr1=reverse_bits_table[*ptr2++];
+	*ptr=*ptr1=rev_bits_table[*ptr2++];
 	ptr+=GR_WIDTH>>3;
 	ptr1+=GR_WIDTH>>3;
      }
@@ -1,260 +0,0 @@
-//See $LK,"::/Doc/Credits.TXT"$.
-
-U64 sys_font_8x8[256]= {
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0000000000000000,
-0x0008000000000000,//
-0x0000000000000000,//
-0x00180018183C3C18,//!
-0x0000000000363636,//"
-0x006C6CFE6CFE6C6C,//#
-0x00187ED07C16FC30,//$$
-0x0060660C18306606,//%
-0x00DC66B61C36361C,//&
-0x0000000000181818,//'
-0x0030180C0C0C1830,//(
-0x000C18303030180C,//)
-0x0000187E3C7E1800,//*
-0x000018187E181800,//+
-0x0C18180000000000,//,
-0x000000007E000000,//-
-0x0018180000000000,//.
-0x0000060C18306000,///
-0x003C666E7E76663C,//0
-0x007E181818181C18,//1
-0x007E0C183060663C,//2
-0x003C66603860663C,//3
-0x0030307E363C3830,//4
-0x003C6660603E067E,//5
-0x003C66663E060C38,//6
-0x000C0C0C1830607E,//7
-0x003C66663C66663C,//8
-0x001C30607C66663C,//9
-0x0018180018180000,//:
-0x0C18180018180000,//;
-0x0030180C060C1830,//<
-0x0000007E007E0000,//=
-0x000C18306030180C,//>
-0x001800181830663C,//?
-0x003C06765676663C,//@
-0x006666667E66663C,//A
-0x003E66663E66663E,//B
-0x003C66060606663C,//C
-0x001E36666666361E,//D
-0x007E06063E06067E,//E
-0x000606063E06067E,//F
-0x003C66667606663C,//G
-0x006666667E666666,//H
-0x007E18181818187E,//I
-0x001C36303030307C,//J
-0x0066361E0E1E3666,//K
-0x007E060606060606,//L
-0x00C6C6D6D6FEEEC6,//M
-0x006666767E6E6666,//N
-0x003C66666666663C,//O
-0x000606063E66663E,//P
-0x006C36566666663C,//Q
-0x006666363E66663E,//R
-0x003C66603C06663C,//S
-0x001818181818187E,//T
-0x003C666666666666,//U
-0x00183C6666666666,//V
-0x00C6EEFED6D6C6C6,//W
-0x0066663C183C6666,//X
-0x001818183C666666,//Y
-0x007E060C1830607E,//Z
-0x003E06060606063E,//[
-0x00006030180C0600,//\
-0x007C60606060607C,//]
-0x000000000000663C,//^
-0xFFFF000000000000,//_
-0x000000000030180C,//`
-0x007C667C603C0000,//a
-0x003E6666663E0606,//b
-0x003C6606663C0000,//c
-0x007C6666667C6060,//d
-0x003C067E663C0000,//e
-0x000C0C0C3E0C0C38,//f
-0x3C607C66667C0000,//g
-0x00666666663E0606,//h
-0x003C1818181C0018,//i
-0x0E181818181C0018,//j
-0x0066361E36660606,//k
-0x003C18181818181C,//l
-0x00C6D6D6FE6C0000,//m
-0x00666666663E0000,//n
-0x003C6666663C0000,//o
-0x06063E66663E0000,//p
-0xE0607C66667C0000,//q
-0x000606066E360000,//r
-0x003E603C067C0000,//s
-0x00380C0C0C3E0C0C,//t
-0x007C666666660000,//u
-0x00183C6666660000,//v
-0x006CFED6D6C60000,//w
-0x00663C183C660000,//x
-0x3C607C6666660000,//y
-0x007E0C18307E0000,//z
-0x003018180E181830,//{
-0x0018181818181818,//|
-0x000C18187018180C,//}
-0x000000000062D68C,//~
-0xFFFFFFFFFFFFFFFF,
-0x1E30181E3303331E,//€
-0x007E333333003300,//�
-0x001E033F331E0038,//‚
-0x00FC667C603CC37E,//ƒ
-0x007E333E301E0033,//„
-0x007E333E301E0007,//…
-0x007E333E301E0C0C,//†
-0x3C603E03033E0000,//‡
-0x003C067E663CC37E,//ˆ
-0x001E033F331E0033,//‰
-0x001E033F331E0007,//Š
-0x001E0C0C0C0E0033,//‹
-0x003C1818181C633E,//Œ
-0x001E0C0C0C0E0007,//�
-0x00333F33331E0C33,//Ž
-0x00333F331E000C0C,//�
-0x003F061E063F0038,//�
-0x00FE33FE30FE0000,//‘
-0x007333337F33367C,//’
-0x001E33331E00331E,//“
-0x001E33331E003300,//”
-0x001E33331E000700,//•
-0x007E33333300331E,//–
-0x007E333333000700,//—
-0x1F303F3333003300,//˜
-0x001C3E63633E1C63,//™
-0x001E333333330033,//š
-0x18187E03037E1818,//›
-0x003F67060F26361C,//œ
-0x000C3F0C3F1E3333,//�
-0x70337B332F1B1B0F,//ž
-0x0E1B18187E18D870,//Ÿ
-0x007E333E301E0038,// 
-0x001E0C0C0C0E001C,//¡
-0x001E33331E003800,//¢
-0x007E333333003800,//£
-0x003333331F001F00,//¤
-0x00333B3F3733003F,//¥
-0x00007E007C36363C,//¦
-0x00007E003C66663C,//§
-0x001E3303060C000C,//¨
-0x000003033F000000,//©
-0x000030303F000000,//ª
-0xF81973C67C1B3363,//«
-0xC0F9F3E6CF1B3363,//¬
-0x183C3C1818001800,//
-0x0000CC663366CC00,//®
-0x00003366CC663300,//¯
-0x1144114411441144,//°
-0x55AA55AA55AA55AA,//±
-0xEEBBEEBBEEBBEEBB,//²
-0x1818181818181818,//³
-0x1818181F18181818,//´
-0x1818181F181F1818,//µ
-0x6C6C6C6F6C6C6C6C,//¶
-0x6C6C6C7F00000000,//·
-0x1818181F181F0000,//¸
-0x6C6C6C6F606F6C6C,//¹
-0x6C6C6C6C6C6C6C6C,//º
-0x6C6C6C6F607F0000,//»
-0x0000007F606F6C6C,//¼
-0x0000007F6C6C6C6C,//½
-0x0000001F181F1818,//¾
-0x1818181F00000000,//¿
-0x000000F818181818,//À
-0x000000FF18181818,//Á
-0x181818FF00000000,//Â
-0x181818F818181818,//Ã
-0x000000FF00000000,//Ä
-0x181818FF18181818,//Å
-0x181818F818F81818,//Æ
-0x6C6C6CEC6C6C6C6C,//Ç
-0x000000FC0CEC6C6C,//È
-0x6C6C6CEC0CFC0000,//É
-0x000000FF00EF6C6C,//Ê
-0x6C6C6CEF00FF0000,//Ë
-0x6C6C6CEC0CEC6C6C,//Ì
-0x000000FF00FF0000,//Í
-0x6C6C6CEF00EF6C6C,//Î
-0x000000FF00FF1818,//Ï
-0x000000FF6C6C6C6C,//Ð
-0x181818FF00FF0000,//Ñ
-0x6C6C6CFF00000000,//Ò
-0x000000FC6C6C6C6C,//Ó
-0x000000F818F81818,//Ô
-0x181818F818F80000,//Õ
-0x6C6C6CFC00000000,//Ö
-0x6C6C6CEF6C6C6C6C,//×
-0x181818FF00FF1818,//Ø
-0x0000001F18181818,//Ù
-0x181818F800000000,//Ú
-0xFFFFFFFFFFFFFFFF,//Û
-0xFFFFFFFF00000000,//Ü
-0x0F0F0F0F0F0F0F0F,//Ý
-0xF0F0F0F0F0F0F0F0,//Þ
-0x00000000FFFFFFFF,//ß
-0x006E3B133B6E0000,//à
-0x03031F331F331E00,//á
-0x0003030303637F00,//â
-0x0036363636367F00,//ã
-0x007F660C180C667F,//ä
-0x001E3333337E0000,//å
-0x03063E6666666600,//æ
-0x00181818183B6E00,//ç
-0x3F0C1E33331E0C3F,//è
-0x001C36637F63361C,//é
-0x007736366363361C,//ê
-0x001E33333E180C38,//ë
-0x00007EDBDB7E0000,//ì
-0x03067EDBDB7E3060,//í
-0x003C06033F03063C,//î
-0x003333333333331E,//ï
-0x00003F003F003F00,//ð
-0x003F000C0C3F0C0C,//ñ
-0x003F00060C180C06,//ò
-0x003F00180C060C18,//ó
-0x1818181818D8D870,//ô
-0x0E1B1B1818181818,//õ
-0x000C0C003F000C0C,//ö
-0x0000394E00394E00,//÷
-0x000000001C36361C,//ø
-0x0000001818000000,//ù
-0x0000001800000000,//ú
-0x383C3637303030F0,//û
-0x000000363636361E,//ü
-0x0000003E061C301E,//ý
-0x00003C3C3C3C0000,//þ
-0x0000000000000000,//ÿ
-};
@@ -0,0 +1,132 @@
+//See $LK,"::/Doc/Credits.TXT"$.
+
+U64 sys_font_cyrillic[256]= {
+0x0000000000000000,0x0000000000000000,
+0x000000FF00000000,0x000000FF00FF0000,//ÄÍ
+0x1818181818181818,0x6C6C6C6C6C6C6C6C,//³º
+0x181818F800000000,0x6C6C6CEC0CFC0000,//ÚÉ
+0x1818181F00000000,0x6C6C6C6F607F0000,//¿»
+0x000000F818181818,0x000000FC0CEC6C6C,//ÀÈ
+0x0000001F18181818,0x0000007F606F6C6C,//Ù¼
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0008000000000000,//
+0x0000000000000000,0x00180018183C3C18,// !
+0x0000000000363636,0x006C6CFE6CFE6C6C,//"#
+0x00187ED07C16FC30,0x0060660C18306606,//$$%
+0x00DC66B61C36361C,0x0000000000181818,//&'
+0x0030180C0C0C1830,0x000C18303030180C,//()
+0x0000187E3C7E1800,0x000018187E181800,//*+
+0x0C18180000000000,0x000000007E000000,//,-
+0x0018180000000000,0x0000060C18306000,//./
+0x003C666E7E76663C,0x007E181818181C18,//01
+0x007E0C183060663C,0x003C66603860663C,//23
+0x0030307E363C3830,0x003C6660603E067E,//45
+0x003C66663E060C38,0x000C0C0C1830607E,//67
+0x003C66663C66663C,0x001C30607C66663C,//89
+0x0018180018180000,0x0C18180018180000,//:;
+0x0030180C060C1830,0x0000007E007E0000,//<=
+0x000C18306030180C,0x001800181830663C,//>?
+0x003C06765676663C,0x006666667E66663C,//@A
+0x003E66663E66663E,0x003C66060606663C,//BC
+0x001E36666666361E,0x007E06063E06067E,//DE
+0x000606063E06067E,0x003C66667606663C,//FG
+0x006666667E666666,0x007E18181818187E,//HI
+0x001C36303030307C,0x0066361E0E1E3666,//JK
+0x007E060606060606,0x00C6C6D6D6FEEEC6,//LM
+0x006666767E6E6666,0x003C66666666663C,//NO
+0x000606063E66663E,0x006C36566666663C,//PQ
+0x006666363E66663E,0x003C66603C06663C,//RS
+0x001818181818187E,0x003C666666666666,//TU
+0x00183C6666666666,0x00C6EEFED6D6C6C6,//VW
+0x0066663C183C6666,0x001818183C666666,//XY
+0x007E060C1830607E,0x003E06060606063E,//Z[
+0x00006030180C0600,0x007C60606060607C,//\]
+0x000000000000663C,0xFFFF000000000000,//^_
+0x000000000030180C,0x007C667C603C0000,//`a
+0x003E6666663E0606,0x003C6606663C0000,//bc
+0x007C6666667C6060,0x003C067E663C0000,//de
+0x000C0C0C3E0C0C38,0x3C607C66667C0000,//fg
+0x00666666663E0606,0x003C1818181C0018,//hi
+0x0E181818181C0018,0x0066361E36660606,//jk
+0x003C18181818181C,0x00C6D6D6FE6C0000,//lm
+0x00666666663E0000,0x003C6666663C0000,//no
+0x06063E66663E0000,0xE0607C66667C0000,//pq
+0x000606066E360000,0x003E603C067C0000,//rs
+0x00380C0C0C3E0C0C,0x007C666666660000,//tu
+0x00183C6666660000,0x006CFED6D6C60000,//vw
+0x00663C183C660000,0x3C607C6666660000,//xy
+0x007E0C18307E0000,0x003018180E181830,//z{
+0x0018181818181818,0x000C18187018180C,//|}
+0x000000000062D68C,0xFFFFFFFFFFFFFFFF,//~
+0x1E30181E3303331E,0x007E333333003300,//€�
+0x001E033F331E0038,0x00FC667C603CC37E,//‚ƒ
+0x007E333E301E0033,0x007E333E301E0007,//„…
+0x007E333E301E0C0C,0x3C603E03033E0000,//†‡
+0x003C067E663CC37E,0x001E033F331E0033,//ˆ‰
+0x001E033F331E0007,0x001E0C0C0C0E0033,//Š‹
+0x003C1818181C633E,0x001E0C0C0C0E0007,//Œ�
+0x00333F33331E0C33,0x00333F331E000C0C,//Ž�
+0x003F061E063F0038,0x00FE33FE30FE0000,//�‘
+0x007333337F33367C,0x001E33331E00331E,//’“
+0x001E33331E003300,0x001E33331E000700,//”•
+0x007E33333300331E,0x007E333333000700,//–—
+0x1F303F3333003300,0x001C3E63633E1C63,//˜™
+0x001E333333330033,0x18187E03037E1818,//š›
+0x003F67060F26361C,0x000C3F0C3F1E3333,//œ�
+0x70337B332F1B1B0F,0x0E1B18187E18D870,//žŸ
+0x000F11110F01111F,0x000101010101111F,// ¡
+0x000F0107010F000A,0x001515150E151515,//¢£
+0x000F10100E10100F,0x0011111315191111,//¤¥
+0x001113151911040A,0x001215141414141E,//¦§
+0x001111111111111F,0x000102040A111111,//¨©
+0x00040E1515150E04,0x001010101E111111,//ª«
+0x001F151515151515,0x000E12120E020203,//¬
+0x0013151513111111,0x000E11101C10110E,//®¯
+0x0009151517151509,0x001112141E11111E,//°±
+0x000E11110F010618,0x0007090709070000,//²³
+0x00010101111F0000,0x000E011F110E000A,//´µ
+0x0015150E15150000,0x000F100C100F0000,//¶·
+0x0011131519110000,0x0013151911040A00,//¸¹
+0x0009050305090000,0x00121514141E0000,//º»
+0x001111151B110000,0x0011111F11110000,//¼½
+0x00111111111F0000,0x00040404041F0000,//¾¿
+0x0010101E11110000,0x001F151515150000,//ÀÁ
+0x000E120E02030000,0x0013151311110000,//ÂÃ
+0x0007090701010000,0x000E111C110E0000,//ÄÅ
+0x0009151715090000,0x0012141E111E0000,//ÆÇ
+0x0004120912040000,0x0004091209040000,//ÈÉ
+0x001B091200000000,0x000000000009121B,//ÊË
+0x001C141C090D0B09,0x000E110102040004,//ÌÍ
+0x000304040E040418,0x001E02020F020A04,//ÎÏ
+0x0004040000000000,0x0004040404000000,//ÐÑ
+0x000E000A0A0A0000,0x000A000A0A0A0000,//ÒÓ
+0x0001020408170005,0x00001B0E040E1B00,//ÔÕ
+0x0001020408150205,0x00000E040404040E,//Ö×
+0x00001F0A0A0A0A1F,0x0004040404150E04,//ØÙ
+0x00040E1504040404,0x0001090D1F0D0901,//ÚÛ
+0x001012161F161210,0x000111151F151101,//ÜÝ
+0x0001020408110701,0x000000000C0C0000,//Þß
+0x111F11121414141E,0x101F111111111111,//àá
+0x101F151515151515,0x111F1112141E0000,//âã
+0x040E15150E040400,0x101A111111110000,//äå
+0x101F151515150000,0x0000000000000408,//æç
+0x000000000000000A,0x0000000000000D12,//èé
+0x000E011F110E0408,0x06040E11010E0000,//êë
+0x0006080A0A0A000A,0x0000041F0E0E0E04,//ìí
+0x00000A0011000A00,0x00000E1111110E00,//îï
+0x0010101D1A150911,0x001C1019121D0911,//ðñ
+0x001C0419121D0911,0x10101C1B12030203,//òó
+0x00111F111F111F11,0x0000000600180003,//ôõ
+0x041E141015070502,0x07020E021E020E02,//ö÷
+0x0E040E041F040E04,0x1C08160017001600,//øù
+0x1C080E080F080E08,0x00040E041F040E04,//úû
+0x1C08090A0C0A0908,0x0609040A0A04120C,//üý
+0x001414141E15151E,0xFFFFFFFFFFFFFFFF,//þÿ
+};
@@ -0,0 +1,132 @@
+//See $LK,"::/Doc/Credits.TXT"$.
+
+U64 sys_font_std[256]= {
+0x0000000000000000,0x0000000000000000,
+0x000000FF00000000,0x000000FF00FF0000,//騵
+0x1818181818181818,0x6C6C6C6C6C6C6C6C,//竟
+0x181818F800000000,0x6C6C6CEC0CFC0000,//硭
+0x1818181F00000000,0x6C6C6C6F607F0000,//蕃
+0x000000F818181818,0x000000FC0CEC6C6C,//檀
+0x0000001F18181818,0x0000007F606F6C6C,//椇
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0000000000000000,
+0x0000000000000000,0x0008000000000000,//
+0x0000000000000000,0x00180018183C3C18,// !
+0x0000000000363636,0x006C6CFE6CFE6C6C,//"#
+0x00187ED07C16FC30,0x0060660C18306606,//$$%
+0x00DC66B61C36361C,0x0000000000181818,//&'
+0x0030180C0C0C1830,0x000C18303030180C,//()
+0x0000187E3C7E1800,0x000018187E181800,//*+
+0x0C18180000000000,0x000000007E000000,//,-
+0x0018180000000000,0x0000060C18306000,//./
+0x003C666E7E76663C,0x007E181818181C18,//01
+0x007E0C183060663C,0x003C66603860663C,//23
+0x0030307E363C3830,0x003C6660603E067E,//45
+0x003C66663E060C38,0x000C0C0C1830607E,//67
+0x003C66663C66663C,0x001C30607C66663C,//89
+0x0018180018180000,0x0C18180018180000,//:;
+0x0030180C060C1830,0x0000007E007E0000,//<=
+0x000C18306030180C,0x001800181830663C,//>?
+0x003C06765676663C,0x006666667E66663C,//@A
+0x003E66663E66663E,0x003C66060606663C,//BC
+0x001E36666666361E,0x007E06063E06067E,//DE
+0x000606063E06067E,0x003C66667606663C,//FG
+0x006666667E666666,0x007E18181818187E,//HI
+0x001C36303030307C,0x0066361E0E1E3666,//JK
+0x007E060606060606,0x00C6C6D6D6FEEEC6,//LM
+0x006666767E6E6666,0x003C66666666663C,//NO
+0x000606063E66663E,0x006C36566666663C,//PQ
+0x006666363E66663E,0x003C66603C06663C,//RS
+0x001818181818187E,0x003C666666666666,//TU
+0x00183C6666666666,0x00C6EEFED6D6C6C6,//VW
+0x0066663C183C6666,0x001818183C666666,//XY
+0x007E060C1830607E,0x003E06060606063E,//Z[
+0x00006030180C0600,0x007C60606060607C,//\]
+0x000000000000663C,0xFFFF000000000000,//^_
+0x000000000030180C,0x007C667C603C0000,//`a
+0x003E6666663E0606,0x003C6606663C0000,//bc
+0x007C6666667C6060,0x003C067E663C0000,//de
+0x000C0C0C3E0C0C38,0x3C607C66667C0000,//fg
+0x00666666663E0606,0x003C1818181C0018,//hi
+0x0E181818181C0018,0x0066361E36660606,//jk
+0x003C18181818181C,0x00C6D6D6FE6C0000,//lm
+0x00666666663E0000,0x003C6666663C0000,//no
+0x06063E66663E0000,0xE0607C66667C0000,//pq
+0x000606066E360000,0x003E603C067C0000,//rs
+0x00380C0C0C3E0C0C,0x007C666666660000,//tu
+0x00183C6666660000,0x006CFED6D6C60000,//vw
+0x00663C183C660000,0x3C607C6666660000,//xy
+0x007E0C18307E0000,0x003018180E181830,//z{
+0x0018181818181818,0x000C18187018180C,//|}
+0x000000000062D68C,0xFFFFFFFFFFFFFFFF,//~
+0x1E30181E3303331E,0x007E333333003300,//��
+0x001E033F331E0038,0x00FC667C603CC37E,//�
+0x007E333E301E0033,0x007E333E301E0007,//�
+0x007E333E301E0C0C,0x3C603E03033E0000,//�
+0x003C067E663CC37E,0x001E033F331E0033,//�
+0x001E033F331E0007,0x001E0C0C0C0E0033,//�
+0x003C1818181C633E,0x001E0C0C0C0E0007,//�
+0x00333F33331E0C33,0x00333F331E000C0C,//�
+0x003F061E063F0038,0x00FE33FE30FE0000,//�
+0x007333337F33367C,0x001E33331E00331E,//�
+0x001E33331E003300,0x001E33331E000700,//�
+0x007E33333300331E,0x007E333333000700,//�
+0x1F303F3333003300,0x001C3E63633E1C63,//�
+0x001E333333330033,0x18187E03037E1818,//�
+0x003F67060F26361C,0x000C3F0C3F1E3333,//�
+0x70337B332F1B1B0F,0x0E1B18187E18D870,//�
+0x007E333E301E0038,0x001E0C0C0C0E001C,//嵗
+0x001E33331E003800,0x007E333333003800,//╯
+0x003333331F001F00,0x00333B3F3733003F,//丰
+0x00007E007C36363C,0x00007E003C66663C,//戍
+0x001E3303060C000C,0x000003033F000000,//貝
+0x000030303F000000,0xF81973C67C1B3363,//物
+0xC0F9F3E6CF1B3363,0x183C3C1818001800,//洎
+0x0000CC663366CC00,0x00003366CC663300,//悖
+0x1144114411441144,0x55AA55AA55AA55AA,//停
+0xEEBBEEBBEEBBEEBB,0x1818181818181818,//眾
+0x1818181F18181818,0x1818181F181F1818,//斯
+0x6C6C6C6F6C6C6C6C,0x6C6C6C7F00000000,//須
+0x1818181F181F0000,0x6C6C6C6F606F6C6C,//號
+0x6C6C6C6C6C6C6C6C,0x6C6C6C6F607F0000,//獄
+0x0000007F606F6C6C,0x0000007F6C6C6C6C,//播
+0x0000001F181F1818,0x1818181F00000000,//噶
+0x000000F818181818,0x000000FF18181818,//擱
+0x181818FF00000000,0x181818F818181818,//藏
+0x000000FF00000000,0x181818FF18181818,//霰
+0x181818F818F81818,0x6C6C6CEC6C6C6C6C,//匸
+0x000000FC0CEC6C6C,0x6C6C6CEC0CFC0000,//�
+0x000000FF00EF6C6C,0x6C6C6CEF00FF0000,//帊
+0x6C6C6CEC0CEC6C6C,0x000000FF00FF0000,//昅
+0x6C6C6CEF00EF6C6C,0x000000FF00FF1818,//恘
+0x000000FF6C6C6C6C,0x181818FF00FF0000,//倳
+0x6C6C6CFF00000000,0x000000FC6C6C6C6C,//眑
+0x000000F818F81818,0x181818F818F80000,//婭
+0x6C6C6CFC00000000,0x6C6C6CEF6C6C6C6C,//笫
+0x181818FF00FF1818,0x0000001F18181818,//崷
+0x181818F800000000,0xFFFFFFFFFFFFFFFF,//窙
+0xFFFFFFFF00000000,0x0F0F0F0F0F0F0F0F,//嗲
+0xF0F0F0F0F0F0F0F0,0x00000000FFFFFFFF,//睧
+0x006E3B133B6E0000,0x03031F331F331E00,//颬
+0x0003030303637F00,0x0036363636367F00,//睼
+0x007F660C180C667F,0x001E3333337E0000,//麧
+0x03063E6666666600,0x00181818183B6E00,//緗
+0x3F0C1E33331E0C3F,0x001C36637F63361C,//鴇
+0x007736366363361C,0x001E33333E180C38,//膹
+0x00007EDBDB7E0000,0x03067EDBDB7E3060,//擨
+0x003C06033F03063C,0x003333333333331E,//闀
+0x00003F003F003F00,0x003F000C0C3F0C0C,//貘
+0x003F00060C180C06,0x003F00180C060C18,//覷
+0x1818181818D8D870,0x0E1B1B1818181818,//鏷
+0x000C0C003F000C0C,0x0000394E00394E00,//禴
+0x000000001C36361C,0x0000001818000000,//矙
+0x0000001800000000,0x383C3637303030F0,//𡜍
+0x000000363636361E,0x0000003E061C301E,//𦶠
+0x00003C3C3C3C0000,0xFFFFFFFFFFFFFFFF,//�
+};
@@ -1,25 +1,27 @@
 //This is run in a $LK,"#exe",A="FF:::/Kernel/Kernel.PRJ,KCfg"${}.

 U8 *kernel_cfg_options="MemInit\0HeapInit\0VarInit\0"
-"NoMP\0TextMode\0DontProbe\0AutoMountIDE\0BootRescueDrv\0Help\0";
+"HomeDir\0NoMP\0TextMode\0DontProbe\0AutoMountIDE\0BootRescueDrv\0Help\0";

 #define CFG_MEM_INIT		0
 #define CFG_HEAP_INIT		1
 #define CFG_VAR_INIT		2
-#define CFG_NO_MP		3
-#define CFG_TEXT_MODE		4
-#define CFG_DONT_PROBE		5
-#define CFG_AUTO_MOUNT_IDE	6
-#define CFG_BOOT_RESCUE_DRV	7
-#define CFG_NUM_OPTIONS		8
+#define CFG_HOME_DIR		3
+#define CFG_NO_MP		4
+#define CFG_TEXT_MODE		5
+#define CFG_DONT_PROBE		6
+#define CFG_AUTO_MOUNT_IDE	7
+#define CFG_BOOT_RESCUE_DRV	8
+#define CFG_NUM_OPTIONS		9

-#define CFG_HELP		8
+#define CFG_HELP		9

 class CKernelCfg
 {
  U8 *dsk_cache_size_exp;
  CDoc *add_dev;
  U8 *boot_rescue_drv_file,*boot_rescue_drv_start;
+  U8 *home_dir;
  Bool opts[CFG_NUM_OPTIONS];
  U8 mem_init_val,heap_init_val,var_init_val,
 	boot_drv_let,auto_mount_ide_hd_let,auto_mount_ide_cd_let;
@@ -32,7 +34,7 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
  "\n\nIn anticipation of the drives you will\n"
 	"define shortly, enter the drive letter\n"
 	"of the drive with the account directory.\n"
-	"\n($$PURPLE$$<ENTER>$$FG$$ for cur drv) Home Drv:";
+	"\n($$PURPLE$$<ENTER>$$FG$$ for cur drv) Boot Drv:";
  ch=ToUpper(GetChar);
  if ('A'<=ch<='Z')
    c->boot_drv_let=ch;
@@ -47,12 +49,15 @@ CDoc *KernelCfgAddDev(CKernelCfg *c)
 U0 KernelCfgOptions(CKernelCfg *c)
 {
  I64 i;
-  U8 *st=NULL;
+  U8 *st=NULL,*st2,*st3;
  Bool state;
  do {
    Free(st);
    for (i=0;i<CFG_NUM_OPTIONS;i++)
-      "$$PURPLE$$%13tz$$FG$$:%Z\n",i,kernel_cfg_options,c->opts[i],"ST_OFF_ON";
+      if (i==CFG_HOME_DIR)
+	"$$PURPLE$$%13tz$$FG$$:\"%s\"\n",i,kernel_cfg_options,c->home_dir;
+      else
+	"$$PURPLE$$%13tz$$FG$$:%Z\n",i,kernel_cfg_options,c->opts[i],"ST_OFF_ON";
    "\nType '$$PURPLE$$Help$$FG$$' for help.\n";
    st=GetStr("Option ($$PURPLE$$<ENTER>$$FG$$ when done):","");
    i=LstMatch(st,kernel_cfg_options,LMF_IGNORE_CASE);
@@ -62,6 +67,7 @@ U0 KernelCfgOptions(CKernelCfg *c)
 	    "to a val at boot.\n"
 	    "$$PURPLE$$HeapInit$$FG$$ Initializes MAlloc() memory to a val.\n"
 	    "$$PURPLE$$VarInit$$FG$$ Initializes glbl var memory to a val.\n"
+	    "$$PURPLE$$HomeDir$$FG$$ Set home dir.\n"
 	    "$$PURPLE$$NoMP$$FG$$ No multicore.\n"
 	    "$$PURPLE$$TextMode$$FG$$ Text Mode (requires hard reboot).\n"
 	    "$$PURPLE$$DontProbe$$FG$$ Just prompt CD/DVD ports, don't probe.\n"
@@ -84,6 +90,22 @@ U0 KernelCfgOptions(CKernelCfg *c)
 	    if (state)
 	      c->var_init_val=GetI64("Val (0-255):",255,0,255);
 	    break;
+	  case CFG_HOME_DIR:
+	    st2=GetStr("Home Dir(\"%s\"):",c->home_dir);
+	    if (!*st2)
+	      st2=StrNew("::/Home");
+	    else if (st2[1]!=':') {
+	      st3=MStrPrint("::%s",st2);
+	      Free(st2);
+	      st2=st3;
+	    }
+	    Free(c->home_dir);
+	    c->home_dir=st2;
+	    if (StrCmp(c->home_dir,"::/Home"))
+	      c->opts[i]=TRUE;
+	    else
+	      c->opts[i]=FALSE;
+	    break;
 	  case CFG_AUTO_MOUNT_IDE:
 	    if (state) {
 	      "First HD Drive Let:";
@@ -130,6 +152,7 @@ CKernelCfg *KernelCfgNew()
  CKernelCfg *c=CAlloc(sizeof(CKernelCfg));

  c->add_dev=KernelCfgAddDev(c);
+  c->home_dir=StrNew("::/Home");
  c->dsk_cache_size_exp=GetStr(
 	"Disk Cache Size in Bytes,\n"
 	"gets rounded-up funny,\n"
@@ -143,6 +166,7 @@ U0 KernelCfgDel(CKernelCfg *c)
 {
  DocDel(c->add_dev);
  Free(c->boot_rescue_drv_file);
+  Free(c->home_dir);
  Free(c->dsk_cache_size_exp);
  Free(c);
 }
@@ -450,7 +450,7 @@ U0 G(U8 *ip=INVALID_PTR,CTask *task=NULL)
 	  ">S;\t\t\t//Single step\n"
 	  ">B2;\t\t\t//Clear all break points\n"
 	  ">G2;\t\t\t//Clear all break points and Go\n\n"
-	  "After resuming, <CTRL-ALT-t> changes focus task\n"
+	  "After resuming, <CTRL-ALT-n> next focus task\n"
 	  "After resuming, <CTRL-ALT-v> flushes screen VGA cache\n";
  else {
    LBtr(&task->task_flags,TASKf_DISABLE_BPTS);
@@ -526,7 +526,7 @@ U0 DbgHelp()
 	">G;\t\t\t\t//Resume execution.\n"
 	">G2;\t\t\t\t//B2;VGAFlush;WinFocus;G;\n"
 	">Exit;\t\t\t\t//Exit (kill) task.\n\n"
-	"After resuming, <CTRL-ALT-t> changes focus task.\n"
+	"After resuming, <CTRL-ALT-n> next focus task.\n"
 	"After resuming, <CTRL-ALT-v> flushes screen VGA cache.\n\n";
 }

@@ -560,7 +560,7 @@ U0 Dbg2()

 U0 Fault3(I64 fault_num,I64 fault_err_code)
 {
-  nounusedwarn fault_err_code;
+  no_warn fault_err_code;
  PUSHFD
  CLI
  if (Gs->num && dbg.mp_crash) {
@@ -108,7 +108,7 @@ U0 SysDefinesLoad()
  DefineLstLoad("ST_FILE_ATTRS","R\0H\0S\0V\0D\0A\0 \0 \0X\0T\0Z\0C\0F\0");
  DefineLstLoad("ST_FILE_UTIL_FLAGS","r\0d\0i\0a\0c\0R\0p\0m\0x\0s\0"
 	"D\0F\0T\0S\0A\0J\0G\0Z\0O\0P\0f\0l\0lb\0la\0");
-  DefineLstLoad("ST_BLKDEV_TYPES","NULL\0RAM\0ATA\0ATAPI\0");
+  DefineLstLoad("ST_BLKDEV_TYPES","NULL\0RAM\0ATA\0FILE\0ATAPI\0");
  DefineLstLoad("ST_DRV_TYPES",
 	"NULL\0REDSEA\0FAT32\0ISO9660\0ISO13490\0ISO13346\0NTFS\0UNKNOWN\0");
  DefineLstLoad("ST_COLORS","BLACK\0BLUE\0GREEN\0CYAN\0"
@@ -9,8 +9,8 @@ U0 SysGlblsInit()
  sys_focus_task=Fs;
  QueInit(&sys_macro_root);

-  blkdev.dft_iso_filename="::/Temp/CDDVD.ISO";
-  blkdev.temp_filename="::/Home/Temp.TXT.Z";
+  blkdev.dft_iso_filename=AStrNew("::/Temp/CDDVD.ISO");
+  blkdev.temp_filename=AStrNew("~/Temp.TXT.Z");
  blkdev.dvd_boot_is_good=TRUE;
  #exe {
    if (!kernel_cfg->auto_mount_ide_hd_let)
@@ -24,11 +24,11 @@ U0 SysGlblsInit()
  }

  InDbg(ON);
-  reverse_bits_table	=CAlloc(256);
+  rev_bits_table	=CAlloc(256);
  set_bits_table	=CAlloc(256);
  for (i=0;i<256;i++)
    for (j=0;j<8;j++) {
-      if (Bt(&i,7-j))	LBts(reverse_bits_table+i,j);
+      if (Bt(&i,7-j))	LBts(rev_bits_table+i,j);
      if (Bt(&i,j))	set_bits_table[i]++;
    }

@@ -63,14 +63,17 @@ U0 SysGlblsInit()

 U0 SysGrInit()
 {
-  text.font=sys_font_8x8;
-  text.aux_font=MAlloc(256*FONT_HEIGHT);
-  MemCpy(text.aux_font,text.font,256*FONT_HEIGHT);
-  text.vga_alias=MemVGAAlloc+VGAM_GRAPHICS;
+  U8 *vga_page=MemVGAAlloc;
+  text.font=sys_font_std;
+  text.aux_font=sys_font_cyrillic;
+  text.vga_alias	=vga_page+VGAM_GRAPHICS;
+  text.vga_text_alias	=vga_page+VGAM_TEXT;
  if (!Bt(&sys_run_level,RLf_VGA)) { //if text mode
    text.cols=80;
    text.rows=25;
-    MemSet(VGAM_TEXT,0,text.rows*text.cols<<1);
+    MemSet(text.vga_text_alias,0,text.rows*text.cols<<1);
+    text.border_chars[2] (I64)='ÄÍ³ºÚÉ¿»';
+    text.border_chars[10](U32)='ÀÈÙ¼';
  } else { //if 640x480 16 color
    text.cols=GR_WIDTH/FONT_WIDTH;
    text.rows=GR_HEIGHT/FONT_HEIGHT;
@@ -78,6 +81,8 @@ U0 SysGrInit()
    OutU8(VGAP_DATA,0x0F);
    MemSet(text.vga_alias,0,GR_WIDTH*GR_HEIGHT>>3);
    text.raw_screen_image=CAlloc(GR_WIDTH*GR_HEIGHT/8);
+    text.border_chars[2] (I64)=0x0908070605040302;
+    text.border_chars[10](U32)=0x0D0C0B0A;
  }
 }

@@ -170,7 +175,9 @@ U0 KernelMain()
  "After  BlkDevsInitAll\n";

  ChgDsk(':');
-  Gs->idle_task->cur_dv=blkdev.let_to_drv[ToUpper(blkdev.boot_drv_let)-'A'];
+  #exe {StreamPrint("HomeSet(\"%s\");",kernel_cfg->home_dir);}
+  Gs->idle_task->cur_dv=blkdev.let_to_drv[*blkdev.home_dir-'A'];
+  DrvRep;
  LBts(&sys_run_level,RLf_BLKDEV);

  #exe {
@@ -45,7 +45,8 @@ _extern _SAVE_EXCEPT_REGS U0 SaveExceptRegs(CExcept *t);
 U0 PutExcept(Bool catch_it=TRUE)
 {//Print exception msg and catch exception.
  "Except:%c:",Fs->except_ch;
-  "%P:%P\n",Fs->except_caller1,Fs->except_caller2;
+  "%P:%P:%P:%P\n",Fs->except_caller1,Fs->except_caller2,
+	Fs->except_caller3,Fs->except_caller4;
  Fs->catch_except=catch_it;
 }

@@ -87,10 +88,13 @@ U0 throw(I64 ch=0,Bool no_log=FALSE)
  Fs->except_ch=ch;
  Fs->except_caller1=Caller(1);
  Fs->except_caller2=Caller(2);
+  Fs->except_caller3=Caller(3);
+  Fs->except_caller4=Caller(4);
  Fs->except_rbp=GetRBP;
  Fs->catch_except=FALSE;
  if (!no_log)
-    AdamLog("Except:%c:%p:%p\n",ch,Fs->except_caller1,Fs->except_caller2);
+    AdamLog("Except:%c:%p:%p:%p:%p\n",ch,Fs->except_caller1,Fs->except_caller2,
+	  Fs->except_caller3,Fs->except_caller4);
  while (Fs->next_except!=&Fs->next_except) {
    TestExcept;
    if (Fs->catch_except)
@@ -42,6 +42,10 @@ extern Bool FAT32DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempdee,
 extern U0 FAT32DrvInit(CDrv *dv);
 extern Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
 	CDirEntry *_res,I64 fuf_flags=0);
+extern U0 FClose(CFile *f);
+extern CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0);
+extern Bool FRBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1);
+extern Bool FWBlks(CFile *f,U8 *buf,I64 blk=FFB_NEXT_BLK,I64 cnt=1);
 extern U8 *FileExtRem(U8 *src,U8 *dst=NULL);
 extern Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0);
 extern U8 *FileNameAbs(U8 *name,I64 fuf_flags=0);
@@ -59,10 +63,11 @@ extern Bool IsDbg();
 extern Bool IsDir(U8 *dir_name);
 extern Bool IsRaw();
 extern CBlkDev *Let2BlkDev(U8 drv_let=0,Bool except=TRUE);
+extern I64 Let2BlkDevType(U8 drv_let=0);
 extern CDrv *Let2Drv(U8 drv_let=0,Bool except=TRUE);
 extern U0 MPInt(I64 num,I64 cpu_num=1);
 extern U8 *MStrPrint(U8 *fmt,...);
-extern Bool MkDir(U8 *filename);
+extern Bool MkDir(U8 *filename,I64 entry_cnt=0);
 extern U0 MouseIPSet(I64 x,I64 y,I64 z,I64 l,I64 r);
 extern U0 Msg(I64 code,I64 a1,I64 a2,I64 flags=0);
 extern I64 PopUp(U8 *buf,CTask *parent=NULL,CTask **_pu_task=NULL);
@@ -9,7 +9,7 @@ CTask *adam_task;
 I64 sys_num_spawned_tasks;

 CTask *sys_winmgr_task,*sys_task_being_screen_updated;
-U8 *reverse_bits_table, //Table with U8 bits reversed
+U8 *rev_bits_table, //Table with U8 bits revd
   *set_bits_table; //Table with count of set bits in a U8
 CDate local_time_offset;
 F64 *pow10_I64;
@@ -104,14 +104,14 @@ U0 LoadPass1(U8 *src,U8 *module_base,I64 ld_flags)
 	}
 	break;

-      sub_switch_start:
+      start:
 	case IET_CODE_HEAP:
 	  ptr3=MAlloc(*src(I32 *)++,Fs->code_heap);
 	  break;
 	case IET_ZEROED_CODE_HEAP:
 	  ptr3=CAlloc(*src(I32 *)++,Fs->code_heap);
 	  break;
-      sub_switch_end:
+      end:
 	if (*st_ptr) {
 	  tempex=CAlloc(sizeof(CHashExport));
 	  tempex->str=StrNew(st_ptr);
@@ -126,14 +126,14 @@ U0 LoadPass1(U8 *src,U8 *module_base,I64 ld_flags)
 	}
 	break;

-      sub_switch_start:
+      start:
 	case IET_DATA_HEAP:
 	  ptr3=MAlloc(*src(I64 *)++);
 	  break;
 	case IET_ZEROED_DATA_HEAP:
 	  ptr3=CAlloc(*src(I64 *)++);
 	  break;
-      sub_switch_end:
+      end:
 	if (*st_ptr) {
 	  tempex=CAlloc(sizeof(CHashExport));
 	  tempex->str=StrNew(st_ptr);
@@ -645,20 +645,4 @@ _FSTSW::
 _FCLEX::
 	FCLEX
 	RET
-//************************************
-_FXSAVE::
-	PUSH	RBP
-	MOV	RBP,RSP
-	MOV	RAX,U64 SF_ARG1[RBP]
-	FXSAVE	U64 [RAX]
-	POP	RBP
-	RET1	8
-//************************************
-_FXRSTOR::
-	PUSH	RBP
-	MOV	RBP,RSP
-	MOV	RAX,U64 SF_ARG1[RBP]
-	FXRSTOR	U64 [RAX]
-	POP	RBP
-	RET1	8
 }
@@ -22,6 +22,7 @@ SYS_KERNEL:: //This must match $LK,"CKernel",A="MN:CKernel"$.
 //  ASM Global vars required for 16-bit start-up
 	ALIGN	4,OC_NOP
 SYS_BOOT_SRC::			DU32	BOOT_SRC_NULL;
+SYS_BOOT_BLK::			DU32	0;
 SYS_BOOT_PATCH_TABLE_BASE::	DU32	0;
 SYS_RUN_LEVEL::			DU32	0;
 #exe {StreamPrint("SYS_COMPILE_TIME:: DU64 0x%X;",Now);}
@@ -32,6 +33,10 @@ SYS_BOOT_BASE::	DU32	0;	//Offset from start used by reboot
 SYS_MEM_E801::	DU16	0,0;
 SYS_MEM_E820::	DU8	MEM_NUM_E820_ENTRIES*MEM_E820_ENTRY_SIZE DUP (0);

+SYS_GDT_PTR::	DU16	sizeof(CGDT)-1;
+		DU64	0;
+SYS_PCI_BUSES::	DU16	0;
+
 	ALIGN	16,OC_NOP
 SYS_GDT:: //See $LK,"CGDT",A="MN:CGDT"$
 GDT_NULL:	DU64	0,0;
@@ -46,18 +51,17 @@ GDT_TR:		DU8	MP_MAX_PROCESSORS*16 DUP(0);
 GDT_TR_RING3:	DU8	MP_MAX_PROCESSORS*16 DUP(0);
 #assert $$-SYS_GDT==sizeof(CGDT)

-SYS_GDT_PTR::	DU16	sizeof(CGDT)-1;
-		DU64	0;
-SYS_PCI_BUSES::	DU16	0;
 #assert $$-SYS_KERNEL==sizeof(CKernel)-sizeof(CBinFile)

 //************************************
 CORE0_16BIT_INIT::
-//EBX is $LK,"SYS_BOOT_SRC",A="FF:::/Kernel/KStart.CPP,[SYS_BOOT_SRC]"$. (Val passed from boot blk, $LK,"BootHD",A="FF:::/Adam/Opt/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootDVD",A="FF:::/Adam/Opt/Boot/BootDVD.CPP,BOOT_SRC_DVD"$, & $LK,"BootRAM",A="FF:::/Adam/Opt/Boot/Reboot.CPP,BOOT_SRC_RAM"$.)
+//EAX is $LK,"SYS_BOOT_SRC",A="FF:::/Kernel/KStart.CPP,[SYS_BOOT_SRC]"$. (Val passed from boot blk, $LK,"BootHD",A="FF:::/Adam/Opt/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootDVD",A="FF:::/Adam/Opt/Boot/BootDVD.CPP,BOOT_SRC_DVD"$, & $LK,"BootRAM",A="FF:::/Adam/Opt/Boot/Reboot.CPP,BOOT_SRC_RAM"$.)
+	MOV	ECX,EAX
 	MOV	AX,(BOOT_RAM_LIMIT-BOOT_STK_SIZE)/16
 	MOV	SS,AX
 	MOV	SP,BOOT_STK_SIZE
-	PUSH	EBX	//Will be $LK,"SYS_BOOT_SRC",A="FF:::/Kernel/KStart.CPP,[SYS_BOOT_SRC]"$. See $LK,"BootHD",A="FF:::/Adam/Opt/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootDVD",A="FF:::/Adam/Opt/Boot/BootDVD.CPP,BOOT_SRC_DVD"$ & $LK,"BootRAM",A="FF:::/Adam/Opt/Boot/Reboot.CPP,BOOT_SRC_RAM"$.
+	PUSH	ECX	//Will be $LK,"SYS_BOOT_SRC",A="FF:::/Kernel/KStart.CPP,[SYS_BOOT_SRC]"$. See $LK,"BootHD",A="FF:::/Adam/Opt/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootDVD",A="FF:::/Adam/Opt/Boot/BootDVD.CPP,BOOT_SRC_DVD"$ & $LK,"BootRAM",A="FF:::/Adam/Opt/Boot/Reboot.CPP,BOOT_SRC_RAM"$.
+	PUSH	EBX
 	MOV	AX,VGAM_TEXT/16
 	MOV	ES,AX
 	MOV	U32 ES:[0],'O'+BLUE<<12+('S'+GREEN<<12)<<16
@@ -134,6 +138,7 @@ GET_IP:	POP	BX
 	OR	AL,2
 	OUT	0x92,AL

+	POP	U32 [SYS_BOOT_BLK]
 	POP	U32 [SYS_BOOT_SRC]	//See $LK,"BootHD",A="FF:::/Adam/Opt/Boot/BootHD.CPP,BOOT_SRC_HARDDRV"$, $LK,"BootDVD",A="FF:::/Adam/Opt/Boot/BootDVD.CPP,BOOT_SRC_DVD"$, & $LK,"BootRAM",A="FF:::/Adam/Opt/Boot/Reboot.CPP,BOOT_SRC_RAM"$.

 	CLD
@@ -196,9 +196,11 @@ I64 TaskInit(CTask *task,I64 stk_size)
  task->win_top		=13;
  task->win_bottom	=text.rows-2;

-  if (blkdev.boot_drv_let) //Beware Adam $LK,"TaskInit",A="FF:::/Kernel/KStart.CPP,TaskInit"$. I guess ok until $LK,"ChgDsk",A="FF:::/Kernel/KEnd.CPP,ChgDsk"$().
-    task->cur_dv=blkdev.let_to_drv[ToUpper(blkdev.boot_drv_let)-'A'];
-  task->cur_dir=StrNew("/Home",task);
+  if (blkdev.home_dir) {//Beware Adam $LK,"TaskInit",A="FF:::/Kernel/KStart.CPP,TaskInit"$. I guess ok until $LK,"ChgDsk",A="FF:::/Kernel/KEnd.CPP,ChgDsk"$().
+    task->cur_dv=blkdev.let_to_drv[*blkdev.home_dir-'A'];
+    task->cur_dir=StrNew(blkdev.home_dir+2,task);
+  } else
+    task->cur_dir=StrNew("/Home",task);

  Seed(,task);

@@ -353,7 +355,7 @@ U0 UserTaskCont()
  CDoc *doc;
  Bool cont=TRUE;
  do {
-    cc=CmpCtrlNew(,CCF_PMT|CCF_QUESTION_HELP);
+    cc=CmpCtrlNew(,CCF_CMD_LINE|CCF_PMT|CCF_QUESTION_HELP);
    QueIns(cc,Fs->last_lex);
    try {
      Lex(cc);
@@ -371,7 +373,7 @@ U0 UserTaskCont()

 U0 SrvCmdLine(I64 dummy=0)
 {
-  nounusedwarn dummy;
+  no_warn dummy;
  Fs->win_inhibit=WIG_USER_TASK_DFT;
  if (HashFind("SrvStartUp",adam_task->hash_table,HTT_FUN))
    CallExtStr("SrvStartUp");
@@ -380,7 +382,7 @@ U0 SrvCmdLine(I64 dummy=0)

 U0 UserCmdLine(I64 dummy=0)
 {//A user task ends-up calling this.
-  nounusedwarn dummy;
+  no_warn dummy;
  Fs->win_inhibit=WIG_USER_TASK_DFT;
  if (HashFind("UserStartUp",adam_task->hash_table,HTT_FUN))
    CallExtStr("UserStartUp");
@@ -27,7 +27,8 @@
 #include "KMathB"
 #include "Sched"
 #include "Mem/MakeMem"
-#include "Font8x8"
+#include "FontStd"
+#include "FontCyrillic"
 #include "StrB"
 #include "KHashA"
 #include "KInts"
@@ -1,18 +1,19 @@
 // Main TempleOS header

 #help_index ""
-extern class CTask;
-extern class CDoc;
+extern class CAOT;
+extern class CAOTHeapGlbl;
+extern class CAOTImportExport;
 extern class CCPU;
+extern class CDC;
+extern class CDoc;
+extern class CFile;
 extern class CHashClass;
 extern class CHashFun;
-extern class CAOTImportExport;
 extern class CHeapCtrl;
-extern class CAOTHeapGlbl;
-extern class CAOT;
-extern class CDC;
-extern class CSrvCtrl;
 extern class CIntermediateCode;
+extern class CSrvCtrl;
+extern class CTask;

 #define NULL	0
 #define TRUE	1
@@ -419,6 +420,7 @@ class CKernel
  CBinFile h;
  U32	jmp,
 	boot_src,
+	boot_blk,
 	boot_patch_table_base,
 	sys_run_level;
  CDate	compile_time;
@@ -427,9 +429,9 @@ class CKernel
  U32	boot_base;
  U16	sys_mem_E801[2];
  CMemE820 sys_mem_E820[MEM_NUM_E820_ENTRIES];
-  CGDT	sys_gdt;
  CSysLimitBase sys_gdt_ptr;
  U16	sys_pci_busses;
+  CGDT	sys_gdt;
 };

 //Run-Levels
@@ -886,12 +888,12 @@ public class CHashGlblVar:CHashSrcSym
 //See $LK,"TextBase Layer",A="HI:TextBase Layer"$.
 #define ATTRF_BLINK	0x10000000
 #define ATTRF_INVERT	0x20000000
-#define ATTRF_SELECTED	0x40000000
+#define ATTRF_SEL	0x40000000
 #define ATTRF_UNDERLINE	0x80000000

 #define ATTRf_BLINK		28
 #define ATTRf_INVERT		29
-#define ATTRf_SELECTED		30
+#define ATTRf_SEL		30
 #define ATTRf_UNDERLINE		31

 //CDocEntry.type codes (Low 8 bits)
@@ -944,13 +946,13 @@ public class CHashGlblVar:CHashSrcSym
 //CDocEntry.type flags upper bits
 #define DOCET_BLINK		ATTRF_BLINK
 #define DOCET_INVERT		ATTRF_INVERT
-#define DOCET_SELECTED		ATTRF_SELECTED
+#define DOCET_SEL		ATTRF_SEL
 #define DOCET_UNDERLINE		ATTRF_UNDERLINE
 #define DOCG_BL_IV_UL		0xB0000000

 #define DOCEt_BLINK		ATTRf_BLINK
 #define DOCEt_INVERT		ATTRf_INVERT
-#define DOCEt_SELECTED		ATTRf_SELECTED
+#define DOCEt_SEL		ATTRf_SEL
 #define DOCEt_UNDERLINE		ATTRf_UNDERLINE

 #define DOCG_DBL_BUF_FLAGS	(DOCF_OVERSTRIKE|DOCF_PLAIN_TEXT|\
@@ -1038,13 +1040,13 @@ public class CHashGlblVar:CHashSrcSym
 #define DOCEF_WORD_WRAP		0x8000000
 #define DOCEF_BLINK		ATTRF_BLINK
 #define DOCEF_INVERT		ATTRF_INVERT
-#define DOCEF_SELECTED		ATTRF_SELECTED
+#define DOCEF_SEL		ATTRF_SEL
 #define DOCEF_UNDERLINE		ATTRF_UNDERLINE
 #define DOCEf_HIGHLIGHT		26
 #define DOCEf_WORD_WRAP		27
 #define DOCEf_BLINK		ATTRf_BLINK
 #define DOCEf_INVERT		ATTRf_INVERT
-#define DOCEf_SELECTED		ATTRf_SELECTED
+#define DOCEf_SEL		ATTRf_SEL
 #define DOCEf_UNDERLINE		ATTRf_UNDERLINE

 //CDocEntry.de_flags.  These first 16 are arg=
@@ -1227,7 +1229,7 @@ class CEdFindText
 	"A=\"Replace     :%s\"$$\n";
  Bool	replace			fmtstr "$$CB,\"Replace\"$$\n",
 	scan_fwd		fmtstr "$$CB,\"Fwd\"$$\n",
-	scan_selected_text	fmtstr "$$CB,\"Selection\"$$\n",
+	scan_sel_text	fmtstr "$$CB,\"Sellection\"$$\n",
 	match_case		fmtstr "$$CB,\"Match Case\"$$\n",
 	whole_labels		fmtstr "$$CB,\"Whole Labels\"$$\n",
 	local_var		fmtstr "$$CB,\"Rename Local Var\"$$\n",
@@ -1280,7 +1282,7 @@ class CEdFileName
 #define DOCF_WORD_WRAP		DOCEF_WORD_WRAP
 #define DOCF_BLINK		DOCEF_BLINK
 #define DOCF_INVERT		DOCEF_INVERT
-#define DOCF_SELECTED		DOCEF_SELECTED
+#define DOCF_SEL		DOCEF_SEL
 #define DOCF_UNDERLINE		DOCEF_UNDERLINE

 #define DOCF_OVERSTRIKE 	0x100000000
@@ -1317,7 +1319,7 @@ class CEdFileName
 #define DOCf_WORD_WRAP		DOCEf_WORD_WRAP
 #define DOCf_BLINK		DOCEf_BLINK
 #define DOCf_INVERT		DOCEf_INVERT
-#define DOCf_SELECTED		DOCEf_SELECTED
+#define DOCf_SEL		DOCEf_SEL
 #define DOCf_UNDERLINE		DOCEf_UNDERLINE

 #define DOCf_OVERSTRIKE 	32
@@ -1618,7 +1620,7 @@ public class CAutoCompleteDictGlbls
 #define ICF_DONT_RESTORE		0x100000000
 #define ICG_NO_CVT_MASK			0x1FFFFFF00

-#define IC_BODY_SIZE			0x80
+#define IC_BODY_SIZE			0x83

 #define ECF_HAS_PUSH_CMP		0x01 //for 50<i<j<=100 exps

@@ -1630,8 +1632,7 @@ U16 class CICType
 class CICArg
 {
  CICType type;
-  U8	type_pointed_to,pad;
-  U16	reg,pad; //low is reg, high is index_reg+scale<<6
+  U16	reg; //low is reg, high is index_reg+scale<<6
  I64	disp;
 };

@@ -1648,7 +1649,7 @@ class CIntermediateCodeBase
  U16	ic_code,
 	ic_precedence;
  I16	ic_cnt,
-	ic_last_cnt;
+	ic_last_start;
 };

 class CIntermediateCode:CIntermediateCodeBase
@@ -1658,9 +1659,10 @@ class CIntermediateCode:CIntermediateCodeBase
 	ic_line;
  CHashClass *ic_class,*ic_class2;
  CICArg a1,a2,r;
+  U8	a1_type_pointed_to; //Used for $LK,"IST_ASSIGN",A="MN:IST_ASSIGN"$ and $LK,"IST_DEREF",A="MN:IST_DEREF"$ $LK,"ic_codes",A="MN:intermediate_code_table"$.
  union {
    U8 ic_body[IC_BODY_SIZE];
-//Tree Links are created in OptPass012.  An ADD opcode, for exmaple,
+    //Tree Links are created in OptPass012.  An ADD opcode, for example,
    //points back to its two earlier addend insts, not MAlloced,
    //just pointers to prev CIntermediate codes in the array.

@@ -2024,8 +2026,8 @@ class CCodeCtrl
 #define __TIME__ #exe{StreamPrint("\"%T\"",Now);}
 #define __LINE__ #exe{StreamPrint("%d",\
 	Fs->last_lex->lex_include_stk->line_num);}
-#define __DEPTH__ #exe{StreamPrint("%d",\
-	Fs->last_lex->lex_include_stk->depth);}
+#define __CMD_LINE__ #exe{StreamPrint("%d",Fs->last_lex->flags&CCF_CMD_LINE &&\
+	Fs->last_lex->lex_include_stk->depth<2);}
 #define __FILE__ #exe{StreamPrint("\"%s\"",\
 	Fs->last_lex->lex_include_stk->full_name);}
 #define __DIR__  #exe{StreamDir;}
@@ -2122,18 +2124,19 @@ class CLexHashTableContext
 };

 //CmpCtrl flags
-#define CCF_PMT			1
-#define CCf_PMT			0
-#define CCF_QUESTION_HELP	2
-#define CCF_DONT_FREE_BUF	4
-#define CCF_NO_DEFINES		8
-#define CCF_IN_IF		16
-#define CCF_JUST_LOAD		32
-#define CCF_KEEP_NEW_LINES	64
-#define CCF_KEEP_DOT		128
-#define CCF_KEEP_NUM_SIGN	256
-#define CCF_KEEP_AT_SIGN	512
-#define CCf_PASS_TRACE_PRESENT	10
+#define CCF_CMD_LINE		0x001
+#define CCF_PMT			0x002
+#define CCf_PMT			1
+#define CCF_QUESTION_HELP	0x004
+#define CCF_DONT_FREE_BUF	0x008
+#define CCF_NO_DEFINES		0x010
+#define CCF_IN_IF		0x020
+#define CCF_JUST_LOAD		0x040
+#define CCF_KEEP_NEW_LINES	0x080
+#define CCF_KEEP_DOT		0x100
+#define CCF_KEEP_NUM_SIGN	0x200
+#define CCF_KEEP_AT_SIGN	0x400
+#define CCf_PASS_TRACE_PRESENT	11
 #define CCF_NOT_CONST		0x0000010000
 #define CCF_NO_REG_OPT		0x0000020000
 #define CCF_IN_QUOTES		0x0000040000
@@ -2277,7 +2280,7 @@ public class CATARep
 #define ATAR0_SECT	3
 #define ATAR0_LCYL	4
 #define ATAR0_HCYL	5
-#define ATAR0_SELECT	6
+#define ATAR0_SEL	6
 #define ATAR0_STAT	7
 #define ATAR0_CMD	7
 #define ATAR1_CTRL	2
@@ -2293,7 +2296,6 @@ public class CATARep
 #define BLK_SIZE_BITS	9
 #define BLK_SIZE	(1<<BLK_SIZE_BITS)
 #define DVD_BLK_SIZE	(4*BLK_SIZE)
-#define DVD_FILE_OFFSET	80
 #define INVALID_CLUSTER (-1)

 class CMBRPrt
@@ -2321,7 +2323,7 @@ class CRedSeaBoot
 {
  U8	jump_and_nop[3],
 	signature,reserved[4]; //MBR_PT_REDSEA=0x88. Distinguish from real FAT32
-  I64	base_offset,	//For CD/DVD image copy.
+  I64	drv_offset,	//For CD/DVD image copy.
 	sects,
 	root_cluster,
 	bitmap_sects,
@@ -2543,8 +2545,7 @@ class CISO1PriDesc
 #help_index "File/Low Level;File/Program Routines"
 //CDirEntry flags (Used by $LK,"FileMgr",A="MN:FileMgr"$())
 #define DEF_PROCESSED		1
-#define DEF_REMOVABLE		2
-#define DEF_NOT_INITIALIZED	4
+#define DEF_NOT_INITIALIZED	2

 #define CDIR_FILENAME_LEN	38 //Must include terminator zero
 public class CDirEntry
@@ -2627,8 +2628,9 @@ public class CDirEntry
 #define BDT_NULL		0
 #define BDT_RAM			1
 #define BDT_ATA			2
-#define BDT_ATAPI		3
-#define BDT_NUM_TYPES		4
+#define BDT_FILE		3
+#define BDT_ATAPI		4
+#define BDT_NUM_TYPES		5

 #define BDF_REMOVABLE		0x001
 #define BDF_INITIALIZED		0x002
@@ -2664,9 +2666,12 @@ public class CBlkDev
  U8	first_drv_let,unit,pad[2];
  U32	base0,base1,
 	blk_size;
-  I64	min_blk,max_blk;
+  I64	drv_offset,init_root_dir_blks,
+	max_blk;
  U16	*dev_id_record;
-  U8	*RAM_dsk;
+  U8	*RAM_dsk,
+	*file_dsk_name;
+  CFile *file_dsk;
  CTask *owning_task;
  F64	last_time;
  U32	max_reads,max_writes;
@@ -2716,7 +2721,7 @@ public class CDrv
  U32	dv_signature;
  U8	drv_let,pad;
  U16	fs_type;
-  I64	base_offset,
+  I64	drv_offset,
 	size,
 	file_system_info_sect,
 	fat1,fat2,
@@ -2751,6 +2756,7 @@ public class CBlkDevGlbls
  CBlkDev *blkdevs;
  U8	*dft_iso_filename;  //See $LK,"blkdev.dft_iso_filename",A="FF:::/Kernel/KEnd.CPP,blkdev.dft_iso_filename"$
  U8	*temp_filename;
+  U8	*home_dir;
  CCacheBlk *cache_base,*cache_ctrl,**cache_hash_table;
  I64	cache_size,read_cnt,write_cnt;
  CDrv	*drvs,*let_to_drv[32];
@@ -2909,7 +2915,7 @@ public class CHeapCtrl
  CMemUnused *heap_hash[MEM_HEAP_HASH_SIZE/sizeof(U8 *)];
 };

-#help_index "Devices"
+#help_index "Devices;Memory/Page Tables"
 public class CDevGlbls
 {
  I64	*idt;
@@ -3364,7 +3370,7 @@ U0 pad;#assert $$==offset(CTaskDying.wake_jiffy)
  CExcept *next_except,*last_except;
  I64	except_rbp,	//throw routine's RBP
 	except_ch;	//throw(ch)
-  U8	*except_caller1,*except_caller2;
+  U8	*except_caller1,*except_caller2,*except_caller3,*except_caller4;

  Bool	catch_except;
  Bool	new_answer;
@@ -3596,7 +3602,8 @@ public class CTextGlbls
  U8	*raw_screen_image;
  I64	rows,cols;		//Use TEXT_ROWS,TEXT_COLS
  U64	*font,*aux_font;
-  U8	*vga_alias;
+  U8	*vga_alias,*vga_text_alias;
+  U8	border_chars[16];
 };

 #define FONT_WIDTH	8
@@ -3877,9 +3884,10 @@ public class CDbgGlbls
 #define BOOT_STK_SIZE		BLK_SIZE

 #define BOOT_SRC_NULL		0
-#define BOOT_SRC_RAM		1
-#define BOOT_SRC_HARDDRV	2
-#define BOOT_SRC_DVD		3
+#define BOOT_SRC_ROM		1
+#define BOOT_SRC_RAM		2
+#define BOOT_SRC_HARDDRV	3
+#define BOOT_SRC_DVD		4

 // $LK,"Auto",A="MN:Auto"$("") StdIn for call to $LK,"MakeOSDrvBootInstall",A="MN:MakeOSDrvBootInstall"$().
 #define STD_DISTRO_DVD_CFG	"Tb\nScale2Mem(2048,0x40000)\nt \n\n\n\n"
@@ -35,6 +35,7 @@ public _extern _LBEQU Bool LBEqu(

 #help_index "Boot"
 _extern SYS_BOOT_BASE U32 sys_boot_base;
+_extern SYS_BOOT_BLK U32 sys_boot_blk;
 _extern SYS_BOOT_PATCH_TABLE_BASE U32 sys_boot_patch_table_base;
 _extern SYS_BOOT_SRC U32 sys_boot_src;
 _extern SYS_RUN_LEVEL U32 sys_run_level;
@@ -66,7 +67,7 @@ public _intern IC_QUE_INIT U0 QueInit(
 public _intern IC_QUE_INS U0 QueIns(
 	CQue *entry,CQue *pred);//Insert item into que after predecessor.
 public _intern IC_QUE_INS_REV U0 QueInsRev(
-	CQue *entry,CQue *succ);//Reversed insert into que.
+	CQue *entry,CQue *succ);//Revd insert into que.
 //Ins item into que before successor.
 public _intern IC_QUE_REM U0 QueRem(CQue *entry); //Remove item from queue.

@@ -130,8 +131,6 @@ _extern _FLDCW U0 Fldcw(U16 w);
 public _extern _FLOOR F64 Floor(F64 d); //Floor of F64.
 _extern _FSTCW U16 Fstcw();
 _extern _FSTSW U16 Fstsw();
-_extern _FXRSTOR U0 Fxrstor(CFPU *fpu_mmx);
-_extern _FXSAVE  U0 Fxsave(CFPU *fpu_mmx);
 public _extern _LN  F64 Ln(F64 d); //Logarithm.
 public _extern _LOG10 F64 Log10(F64 d); //Log base 10.
 public _extern _LOG2 F64 Log2(F64 d); //Log base 2.
@@ -7,7 +7,7 @@ public extern CAutoCompleteDictGlbls acd;

 #help_index "Bit"
 public extern I64 BCnt(I64 d);
-public extern U8 *reverse_bits_table,*set_bits_table;
+public extern U8 *rev_bits_table,*set_bits_table;

 #help_index "Boot"
 #help_file "::/Doc/Boot"
@@ -60,7 +60,6 @@ public extern I64 LstMatch(U8 *needle, U8 *haystack_lst,I64 flags=0);
 public extern U8 *LstSub(I64 sub, U8 *lst);

 #help_index "Char/Operations"
-public extern U8 *CatPrint(U8 *dst,U8 *fmt,...);
 public extern U8 *MStrPrint(U8 *fmt,...);
 public extern U8 *MStrUtil(U8 *src,I64 flags,F64 indent_scale_factor=0);
 public extern U8 *ScaleIndent(U8 *src,F64 indent_scale_factor);
@@ -84,6 +83,9 @@ public extern U8 *StrUtil(U8 *_src,I64 flags);
 public extern U8 *Tabs2Spaces(U8 *src);
 public extern Bool WildMatch(U8 *test_str,U8 *wild_str);

+#help_index "Char/Operations;Memory"
+public extern U8 *CatPrint(U8 *dst,U8 *fmt,...);
+
 #help_index "Char/Operations;Memory/Adam Heap"
 public extern U8 *AStrNew(U8 *buf);

@@ -280,7 +282,8 @@ public extern I64 Del(U8 *files_find_mask,Bool make_mask=FALSE,
 	Bool del_dir=FALSE,Bool print_msg=TRUE);
 public extern I64 Dir(U8 *files_find_mask="*",Bool full=FALSE);
 public extern Bool Drv(U8 drv_let);
-public extern Bool MkDir(U8 *filename);
+public extern U0 HomeSet(U8 *dirname);
+public extern Bool MkDir(U8 *filename,I64 entry_cnt=0);

 #help_index "File/Cmd Line (Typically);Cmd Line (Typically);Install"
 public extern Bool DrvMap(U8 drv_let,CDrv *dv);
@@ -302,8 +305,9 @@ public extern Bool FilesFindMatch(U8 *_test_name,
 public extern Bool IsDir(U8 *dir_name);
 public extern Bool IsDotC(U8 *filename);
 public extern Bool IsDotZ(U8 *filename);
-public extern U0 PutDirLink(U8 *dirname);
-public extern U0 PutFileLink(U8 *filename,I64 line=0,Bool plain_text=FALSE);
+public extern U0 PutDirLink(U8 *dirname,U8 *full_name=NULL);
+public extern U0 PutFileLink(U8 *filename,U8 *full_name=NULL,
+	I64 line=0,Bool plain_text=FALSE);
 public extern U0 ToFileLine(U8 *_fl_file_line,U8 **_filename,I64 *_linenum);
 public extern U8 *ToggleZorNotZ(U8 *name);

@@ -321,6 +325,7 @@ extern I64 FileAttr(U8 *name,I64 old_attr=0);
 #help_index "File/Low Level"
 #help_file "::/Doc/FileLowLevel"
 public extern CBlkDev *BlkDevChk(CBlkDev *bd,Bool except=TRUE);
+public extern U0 BlkDevDel(CBlkDev *bd);
 public extern Bool BlkDevLock(CBlkDev *bd);
 public extern CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type);
 public extern Bool BlkDevUnlock(CBlkDev *bd,Bool rst=FALSE);
@@ -332,6 +337,7 @@ public extern I64 ClustersAlloc(CDrv *dv,I64 c=0,
 extern Bool CopySingle(U8 *f1,U8 *f2); //Just one file
 public extern U8 Drv2Let(CDrv *dv=NULL);
 public extern CDrv *DrvChk(CDrv *dv,Bool except=TRUE);
+public extern U0 DrvDel(CDrv *dv);
 public extern Bool DrvLock(CDrv *dv);
 public extern CDrv *DrvMakeFree(U8 drv_let);
 public extern U8 *DrvModelNum(U8 drv_let=0);
@@ -369,8 +375,8 @@ public extern I64 FileWrite(U8 *filename,
 public extern CDirEntry *FilesFind(U8 *files_find_mask,I64 fuf_flags=0);

 #help_index "File/System"
-public extern CATARep *ATAIDDrvs(CATARep *root,
-	I64 _sys_boot_drv,CATARep **_ata_drv,CATARep **_atapi_drv);
+public extern CATARep *ATAIDDrvs(CATARep *root,CATARep **_ata_drv,
+	CATARep **_atapi_drv);
 extern CBlkDev *ATAMount(U8 first_drv_let,
 	I64 type,I64 base0,I64 base1,I64 unit);
 extern Bool ATAPIStartStop(CBlkDev *bd,F64 timeout,Bool start);
@@ -388,7 +394,6 @@ extern U0 (*fp_set_std_palette)();
 public extern U8 *Color2Str(U8 *buf,CColorROPU32 c);
 public extern CColorROPU16 Str2ColorU16(U8 *st);
 public extern CColorROPU32 Str2ColorU32(U8 *st);
-
 #help_index "Hash"
 #help_file "::/Doc/Hash"
 public _extern _HASH_ADD U0 HashAdd(CHash *temph,CHashTable *table);
@@ -402,6 +407,7 @@ public _extern _HASH_SINGLE_TABLE_FIND CHash *HashSingleTableFind(
 	U8 *needle_str,CHashTable *haystack_table,I64 mask,I64 instance=1);
 public _extern _HASH_STR I64 HashStr(U8 *st);
 public extern CHashTable *HashTableNew(I64 size,CTask *mem_task=NULL);
+
 #help_index "Hash/Frame"
 #help_file "::/Doc/Frame"
 public extern I64 FramePtr(U8 *name,CTask *task=NULL);
@@ -61,28 +61,30 @@ U0 KeyDescSet(U8 *fmt,...)
  Free(buf);
 }

-CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),
-	Bool (*fp_puts)(U8 *st),I64 priority,Bool key_descs=FALSE)
-{//Places hook in StdOut chain. See $LK,"Keyboard Devices",A="HI:Keyboard Devices/System"$.
-  CKeyDevEntry *tempp,*tempp1=keydev.put_key_root.last;
-  tempp=ACAlloc(sizeof(CKeyDevEntry));
-  tempp->put_key=fp_put_key;
-  tempp->put_s=fp_puts;
-  tempp->priority=priority;
-  if (key_descs)
-    tempp->flags|=KDF_HAS_DESCS;
-  while (tempp1->priority>priority)
-    tempp1=tempp1->last;
-  QueIns(tempp,tempp1);
-  return tempp;
-}
-
 U0 KeyDevRem(CKeyDevEntry *tempp)
 {//Remove StdOut hook and free.
  QueRem(tempp);
  Free(tempp);
 }

+CKeyDevEntry *KeyDevAdd(Bool (*fp_put_key)(I64 ch,I64 sc),
+	Bool (*fp_puts)(U8 *st),I64 priority,Bool key_descs=FALSE)
+{//Places hook in StdOut chain. See $LK,"Keyboard Devices",A="HI:Keyboard Devices/System"$.
+  CKeyDevEntry *tempp=keydev.put_key_root.last,
+	*tempp1=ACAlloc(sizeof(CKeyDevEntry));
+  tempp1->put_key=fp_put_key;
+  tempp1->put_s=fp_puts;
+  tempp1->priority=priority;
+  if (key_descs)
+    tempp1->flags|=KDF_HAS_DESCS;
+  while (tempp->priority>priority)
+    tempp=tempp->last;
+  QueIns(tempp1,tempp);
+  if (tempp->priority==priority)
+    KeyDevRem(tempp);
+  return tempp1;
+}
+
 Bool KDRawPutKey(I64 ch,I64)
 {
  if (IsRaw) {
@@ -143,11 +145,6 @@ U0 CtrlAltD(I64)
  }
 }

-U0 CtrlAltE(I64)
-{
-  User;
-}
-
 U0 CtrlAltF(I64)
 {
  SwapI64(&text.font,&text.aux_font);
@@ -158,11 +155,16 @@ U0 CtrlAltM(I64)
  Mute(!IsMute);
 }

-U0 CtrlAltT(I64)
+U0 CtrlAltN(I64)
 {
  LBts(sys_ctrl_alt_flags,SYSf_CTRL_ALT_TAB);
 }

+U0 CtrlAltT(I64)
+{
+  User;
+}
+
 U0 CtrlAltV(I64)
 {
  VGAFlush;
@@ -208,10 +210,10 @@ U0 KeyDevInit()
  KeyDevAdd(&KDRawPutKey,&KDRawPutS,0x60000000,FALSE);
  CtrlAltCBSet('C',&CtrlAltC,"Cmd /Break Execution",,TRUE);
  CtrlAltCBSet('D',&CtrlAltD,"Cmd /Enter Debugger",,TRUE);
-  CtrlAltCBSet('E',&CtrlAltE,"Cmd /Spawn New User Task");
  CtrlAltCBSet('F',&CtrlAltF,"Cmd /Toggle Aux Font");
  CtrlAltCBSet('M',&CtrlAltM,"Cmd /Toggle Mute");
-  CtrlAltCBSet('T',&CtrlAltT,"Cmd /Switch Focus to Next Task",,TRUE);
+  CtrlAltCBSet('N',&CtrlAltN,"Cmd /Next Focus Task",,TRUE);
+  CtrlAltCBSet('T',&CtrlAltT,"Cmd /Terminal Window");
  CtrlAltCBSet('V',&CtrlAltV,"Cmd /VGA Flush",,TRUE);
  CtrlAltCBSet('X',&CtrlAltX,"Cmd /Kill Focused Task",,TRUE);
 }
@@ -36,8 +36,8 @@ U0 Mem32DevInit()
  tempmr=AMAlloc(sizeof(CMemRange));
  tempmr->type=MRT_UNUSED;
  tempmr->flags=0;
-//Maybe !!! Change this to 0xE0000000 !!!
-  tempmr->base=0xF0000000;
+//Maybe !!! Change this to 0xF0000000 !!!
+  tempmr->base=0xE0000000;
  tempmr->size=0x10000000;
  QueIns(tempmr,dev.mem32_root.last);

@@ -156,7 +156,7 @@ U0 Mem64DevFree(U8 *base,I64 pages2Meg)
 U8 *MemVGAAlloc()
 {
  I64 i=1,*a=Mem64DevAlloc(&i),*pte=MemPageTable(a);
-  *pte=0x18F;
+  *pte=0x197;
  InvlPg(a);
  return a;
 }
@@ -26,7 +26,7 @@ The scheduler checks for a few keys:

 <CTRL-ALT-x> kill a task.
 <CTRL-ALT-DEL> reboots.
-<CTRL-ALT-t> changes focus to next task.
+<CTRL-ALT-n> Next task.
 <CTRL-ALT-c> breaks execution of a program.

 Each core has its own circular task queue.
@@ -362,9 +362,9 @@ U0 KbdBuildSC(U8 raw_byte,Bool in_irq,U8 *_last_raw_byte,I64 *_last_sc)
 	CtrlAltDel(sc);
      else {
 	if (sc&255==SC_ESC)
-	  ch='e';
-	else if (sc&255==SC_TAB)
 	  ch='t';
+	else if (sc&255==SC_TAB)
+	  ch='n';
 	else
 	  ch=ScanCode2Char(sc&255);
 	if ('a'<=ch<='z') {
@@ -216,7 +216,7 @@ U0 KbdMouseRst()

 Bool MouseDriverInstall(I64 dummy=0) //can be spawned
 {
-  nounusedwarn dummy;
+  no_warn dummy;
  I64 i;
  mouse.install_in_progress=TRUE;
  OutU8(0xA1,InU8(0xA1)|0x10);
@@ -139,7 +139,7 @@ U8 *MPrintq(U8 *ptr,I64 flags)
      switch (ch) {
 	case '\\':
 	  switch (ch1) {
-	    sub_switch_start:
+	    start:
 	      case 'n':
 		SPutChar(_dst,'\n',_buf);
 		break;
@@ -164,7 +164,7 @@ U8 *MPrintq(U8 *ptr,I64 flags)
 	      case '0':
 		SPutChar(_dst,0,_buf);
 		break;
-	    sub_switch_end:
+	    end:
 	      ptr++;
 	      break;

@@ -281,7 +281,7 @@ to avoid this.
      aux_fmt_num=0;
      while (TRUE) {
 	switch (*fmt) {
-	  sub_switch_start:
+	  start:
 	    case '$$':
 	      flags|=SPF_DOLLAR;
 	      break;
@@ -296,7 +296,7 @@ to avoid this.
 	      break;
 	    case 'l': //harmless
 	      break;
-	  sub_switch_end:
+	  end:
 	    fmt++;
 	    break;

@@ -332,7 +332,7 @@ to avoid this.
      sp_arg:
      k=0;
      switch (*fmt++) {
-	sub_switch_start:
+	start:
 	  case 'F':
 	    if (cur_arg>=argc)
 	      throw('StrPrint');
@@ -365,12 +365,12 @@ to avoid this.
 	      throw('StrPrint');
 	    ptr=MPrintTime(argv[cur_arg++]);
 	    break;
-	sub_switch_end:
+	end:
 	  OutStr(ptr,_buf,_dst,len,flags);
 	  Free(ptr);
 	  break;

-	sub_switch_start:
+	start:
 	  case 's':
 	    if (cur_arg>=argc)
 	      throw('StrPrint');
@@ -393,11 +393,11 @@ to avoid this.
 	    ptr=DefineSub(argv[cur_arg],argv[cur_arg+1]);
 	    cur_arg=cur_arg+2;
 	    break;
-	sub_switch_end:
+	end:
 	  OutStr(ptr,_buf,_dst,len,flags);
 	  break;

-	sub_switch_start:
+	start:
 	  case 'c':
 	    if (cur_arg>=argc)
 	      throw('StrPrint');
@@ -415,7 +415,7 @@ to avoid this.
 	      ptr++;
 	    }
 	    break;
-	sub_switch_end:
+	end:
 	  if (!(flags&SPF_AUX_FMT_NUM))
 	    aux_fmt_num=1;
 	  while (aux_fmt_num-->0)