TempleOSCDV4.02.ISO

Kernel/BlkDev/DskATAId.CPP

@@ -207,12 +207,7 @@ CATARep *ATAIDDrvs(CATARep *root,I64 _sys_boot_drv,
   CATARep *result=NULL,*tempha=root,*ata_drv=NULL,*atapi_drv=NULL;
   CBlkDev *bd;
   Bool was_silent=Silent;
-  try
-	  bd=Let2BlkDev(_sys_boot_drv);
-  catch {
-    Fs->catch_except=TRUE;
-    bd=NULL;
-  }
+  bd=Let2BlkDev(_sys_boot_drv,FALSE);
   Silent(was_silent);
   while (tempha) {
     if (!result && bd && bd->type==tempha->type) {

Kernel/BlkDev/DskAddDev.CPP

@@ -37,7 +37,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
   switch (bd->type) {
     case BDT_RAM:
       dv->dv_signature=DRV_SIGNATURE_VAL;
-      dv->type=DVT_REDSEA;
+      dv->fs_type=FSt_REDSEA;
 //This is to force creation of a RAM
       //drive during boot, so it is probably
       //MAlloced to the same addr and can
@@ -59,7 +59,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 	if (one_drv) {
 	  dv->dv_signature=DRV_SIGNATURE_VAL;
 	  result++;
-	  dv->type=DVT_REDSEA;
+	  dv->fs_type=FSt_REDSEA;
 	  dv->size=bd->max_blk+1;
 //The following read is a test read.
 	  //if it hangs, the drive is not supported.
@@ -86,7 +86,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 		case MBR_PT_REDSEA:
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
 		  result++;
-		  dv->type=DVT_REDSEA;
+		  dv->fs_type=FSt_REDSEA;
 		  RedSeaDrvInit(dv);
 		  break;
 		case MBR_PT_FAT32a:
@@ -99,17 +99,17 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
 		  result++;
 		  if (br.signature==MBR_PT_REDSEA) {
-		    dv->type=DVT_REDSEA;
+		    dv->fs_type=FSt_REDSEA;
 		    RedSeaDrvInit(dv);
 		  } else {
-		    dv->type=DVT_FAT32;
+		    dv->fs_type=FSt_FAT32;
 		    FAT32DrvInit(dv);
 		  }
 		  break;
 		case MBR_PT_NTFS:
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
 		  result++;
-		  dv->type=DVT_NTFS;
+		  dv->fs_type=FSt_NTFS;
 		  break;
 		case 5:
 		case 15:
@@ -118,7 +118,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 		default:
 		  dv->dv_signature=DRV_SIGNATURE_VAL;
 		  result++;
-		  dv->type=DVT_UNKNOWN;
+		  dv->fs_type=FSt_UNKNOWN;
 	      }
 	    }
 	  }
@@ -137,7 +137,7 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
     case BDT_ATAPI:
       dv->dv_signature=DRV_SIGNATURE_VAL;
       result++;
-      dv->type=DVT_ISO9660; //Start with this
+      dv->fs_type=FSt_ISO9660; //Start with this
       dv->size =0;
       break;
   }
@@ -151,13 +151,10 @@ I64 BlkDevAdd(CBlkDev *bd,Bool one_drv,Bool make_free)
 Bool DrvEnable(U8 drv_let,Bool val)
 {//Can unmount or remount, but not mount the first time.
   CDrv *dv;
-  Bool result=FALSE;
-  try {
-    dv=Let2Drv(drv_let);
-    result=!LBEqu(&dv->type,DVTf_DISABLE,!val);
-  } catch
-    Fs->catch_except=TRUE;
-  return result;
+  if (dv=Let2Drv(drv_let,FALSE))
+    return !LBEqu(&dv->fs_type,FStf_DISABLE,!val);
+  else
+    return FALSE;
 }
 
 I64 SysGetI64()

Kernel/BlkDev/DskBlkDev.CPP

@@ -40,7 +40,7 @@ Bool BlkDevInit(CBlkDev *bd)
 	  bd->RAM_dsk=AMAlloc((bd->max_blk+1)<<BLK_SIZE_BITS);
 	  bd->max_blk=MSize(bd->RAM_dsk)>>BLK_SIZE_BITS-1;
 	}
-	dv->type=DVT_REDSEA;
+	dv->fs_type=FSt_REDSEA;
 	dv->size=bd->max_blk+1;
 	if (RedSeaDrvValidate(bd->first_drv_let))
 	  RedSeaDrvInit(dv);
@@ -116,17 +116,23 @@ CBlkDev *BlkDevNextFree(U8 first_drv_let,I64 type)
   return NULL; //never gets here
 }
 
-U0 BlkDevChk(CBlkDev *bd)
+CBlkDev *BlkDevChk(CBlkDev *bd,Bool except=TRUE)
 {//Check for valid BlkDev. Throw exception.
   if (!bd || bd->bd_signature!=BD_SIGNATURE_VAL ||
-	!(BDT_NULL<bd->type<BDT_NUM_TYPES))
-    throw('BlkDev');
+	!(BDT_NULL<bd->type<BDT_NUM_TYPES)) {
+    if (except)
+      throw('BlkDev');
+    else
+      return NULL;
+  } else
+    return bd;
 }
 
-CBlkDev *Let2BlkDev(U8 drv_let=0)
+CBlkDev *Let2BlkDev(U8 drv_let=0,Bool except=TRUE)
 {//Drv letter to BlkDev ptr.
-  CDrv *dv=Let2Drv(drv_let);
-  CBlkDev *bd=dv->bd;
-  BlkDevChk(bd);
-  return bd;
+  CDrv *dv;
+  if (dv=Let2Drv(drv_let,except))
+    return BlkDevChk(dv->bd,except);
+  else
+    return NULL;
 }

Kernel/BlkDev/DskCFile.CPP

@@ -23,11 +23,12 @@ CFile *FOpen(U8 *filename,U8 *flags,I64 cnt=0)
   f->file_cluster_num=INVALID_CLUSTER;
   full_name=FileNameAbs(filename);
   f->dv=Let2Drv(*full_name);
-  if (f->dv->type==DVT_REDSEA)
+  if (f->dv->fs_type==FSt_REDSEA)
     contiguous=TRUE;
   if (contiguous) {
     f->flags|=FF_CONTIGUOUS;
-    if (f->dv->type!=DVT_REDSEA && !(FileAttr(filename) & RS_ATTR_CONTIGUOUS))
+    if (f->dv->fs_type!=FSt_REDSEA &&
+	  !(FileAttr(filename) & RS_ATTR_CONTIGUOUS))
       throw('File');
   }
   f->cluster_buf=CAlloc(f->dv->spc<<BLK_SIZE_BITS);

Kernel/BlkDev/DskCluster.CPP

@@ -5,12 +5,12 @@ I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1)
   if (cnt<=0) return c;
   try {
     unlock=DrvLock(dv);
-    switch (dv->type) {
-      case DVT_ISO9660:
-      case DVT_REDSEA:
+    switch (dv->fs_type) {
+      case FSt_ISO9660:
+      case FSt_REDSEA:
 	c+=cnt;
 	break;
-      case DVT_FAT32:
+      case FSt_FAT32:
 	while (cnt-->0 && 0<c<0x0FFFFFF8) {
 	  DrvFATBlkSet(dv,c);
 	  c=dv->cur_fat_blk[c & (BLK_SIZE/4-1)];
@@ -32,11 +32,11 @@ I64 ClusterNumNext(CDrv *dv,I64 c,I64 cnt=1)
 I64 Cluster2Blk(CDrv *dv,I64 c)
 {//Drv cluster num to blk num.
   DrvChk(dv);
-  switch (dv->type) {
-    case DVT_REDSEA:
+  switch (dv->fs_type) {
+    case FSt_REDSEA:
       return c;
-    case DVT_ISO9660:
-    case DVT_FAT32:
+    case FSt_ISO9660:
+    case FSt_FAT32:
       return dv->data_area+c*dv->spc;
     default:
       throw('Drv');
@@ -51,16 +51,16 @@ I64 RClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
   if (blks<=0) return c;
   try {
     unlock=DrvLock(dv);
-    switch (dv->type) {
-      case DVT_ISO9660:
+    switch (dv->fs_type) {
+      case FSt_ISO9660:
 	RBlks(dv,buf,dv->data_area+c*dv->spc,blks);
 	c+=(blks+dv->spc-1)/dv->spc;
 	break;
-      case DVT_REDSEA:
+      case FSt_REDSEA:
 	RBlks(dv,buf,c,blks);
 	c+=blks;
 	break;
-      case DVT_FAT32:
+      case FSt_FAT32:
 	while (blks && 0<c<0x0FFFFFF8) {
 	  i=blks;
 	  if (i>dv->spc)
@@ -97,12 +97,12 @@ I64 WClustersBlks(CDrv *dv,U8 *buf,I64 c,I64 blks)
   if (blks<=0) return c;
   try {
     unlock=DrvLock(dv);
-    switch (dv->type) {
-      case DVT_REDSEA:
+    switch (dv->fs_type) {
+      case FSt_REDSEA:
 	WBlks(dv,buf,c,blks);
 	c=0;
 	break;
-      case DVT_FAT32:
+      case FSt_FAT32:
 	while (blks) {
 	  if (!(0<c<0x0FFFFFF8))
 	    throw('Drv');
@@ -136,10 +136,10 @@ I64 ClustersAlloc(CDrv *dv,I64 c=0,I64 cnt=1,Bool contiguous=FALSE)
 //c=0 means first cluster in chain
   DrvChk(dv);
   if (cnt<=0) return c;
-  switch (dv->type) {
-    case DVT_REDSEA:
+  switch (dv->fs_type) {
+    case FSt_REDSEA:
       return RedSeaAllocClusters(dv,cnt);
-    case DVT_FAT32:
+    case FSt_FAT32:
       if (contiguous) {
 	if (c) throw('File');
 	return FAT32AllocContiguousClusters(dv,cnt);

Kernel/BlkDev/DskCopy.CPP

@@ -85,16 +85,16 @@ I64 Del(U8 *files_find_mask,Bool make_mask=FALSE,
   I64 result=0;
   CDirContext *dirc;
   if (dirc=DirContextNew(files_find_mask,make_mask)) {
-    switch (dirc->dv->type) {
-      case DVT_REDSEA:
+    switch (dirc->dv->fs_type) {
+      case FSt_REDSEA:
 	result=RedSeaFilesDel(dirc->dv,Fs->cur_dir,dirc->mask,
 	      0,del_dir,print_msg);
 	break;
-      case DVT_FAT32:
+      case FSt_FAT32:
 	result=FAT32FilesDel(dirc->dv,Fs->cur_dir,dirc->mask,
 	      0,del_dir,print_msg);
 	break;
-      case DVT_ISO9660:
+      case FSt_ISO9660:
 	PrintErr("Not Writable\n");
 	break;
       default:

Kernel/BlkDev/DskDirA.CPP

@@ -1,11 +1,11 @@
 Bool DirNew(CDrv *dv,U8 *cur_dir,CDirEntry *tempde,Bool free_old_chain=TRUE)
 {//Makes a directory entry in the directory from a $LK,"CDirEntry",A="MN:CDirEntry"$ node.
-  switch (dv->type) {
-    case DVT_REDSEA:
+  switch (dv->fs_type) {
+    case FSt_REDSEA:
       return RedSeaDirNew(dv,cur_dir,tempde,free_old_chain);
-    case DVT_FAT32:
+    case FSt_FAT32:
       return FAT32DirNew(dv,cur_dir,tempde,free_old_chain);
-    case DVT_ISO9660:
+    case FSt_ISO9660:
       PrintErr("Not Writable\n");
       return FALSE;
     default:

Kernel/BlkDev/DskDirB.CPP

@@ -39,14 +39,14 @@ Bool Cd(U8 *dirname=NULL,Bool make_dirs=FALSE)
     } else if (StrCmp(buf,".") && *buf) {
       dv=Fs->cur_dv;
       cur_dir_cluster=Name2DirCluster(dv,new_cur_dir);
-      switch (dv->type) {
-	case DVT_REDSEA:
+      switch (dv->fs_type) {
+	case FSt_REDSEA:
 	  result=RedSeaCd(buf,cur_dir_cluster);
 	  break;
-	case DVT_FAT32:
+	case FSt_FAT32:
 	  result=FAT32Cd(buf,cur_dir_cluster);
 	  break;
-	case DVT_ISO9660:
+	case FSt_ISO9660:
 	  result=ISO1Cd(buf,cur_dir_cluster);
 	  break;
 	default:
@@ -158,14 +158,14 @@ Bool MkDir(U8 *filename)
 	"Make Directory:%s\n",filename;
 	name=MStrUtil(dirc->mask,
 	      SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
-	switch (dirc->dv->type) {
-	  case DVT_REDSEA:
+	switch (dirc->dv->fs_type) {
+	  case FSt_REDSEA:
 	    result=RedSeaMkDir(dirc->dv,Fs->cur_dir,name);
 	    break;
-	  case DVT_FAT32:
+	  case FSt_FAT32:
 	    result=FAT32MkDir(dirc->dv,Fs->cur_dir,name);
 	    break;
-	  case DVT_ISO9660:
+	  case FSt_ISO9660:
 	    PrintErr("Not Writable\n");
 	    break;
 	  default:

Kernel/BlkDev/DskDirContext.CPP

@@ -22,12 +22,13 @@ CDirContext *DirContextNew(U8 *_mask,Bool make_mask=FALSE,
 	Bool make_dirs=FALSE,Bool no_mask=FALSE)
 {//Save cur_dir and drv. Change to new dir.
   Bool valid=TRUE,old_silent;
-  U8 *buf,*mask,*temp_mask;
+  I64 mask_len=StrLen(_mask);
+  U8 *buf,*mask,*temp_mask,*semicolon_mask;
   CDirContext *dirc=CAlloc(sizeof(CDirContext));
-  mask=MStrUtil(_mask,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
-  temp_mask=mask;
   dirc->old_dir=StrNew(Fs->cur_dir);
   dirc->old_dv=Fs->cur_dv;
+  mask=MStrUtil(_mask,SUF_REM_LEADING|SUF_REM_TRAILING|SUF_REM_CTRL_CHARS);
+  temp_mask=mask;
   if (*mask && mask[1]==':') {
     if (Fs->cur_dv!=Let2Drv(*mask) && !Drv(*mask))
       valid=FALSE;
@@ -35,13 +36,22 @@ CDirContext *DirContextNew(U8 *_mask,Bool make_mask=FALSE,
   }
   dirc->dv=Fs->cur_dv;
   DrvChk(dirc->dv);
-  buf=MAlloc(StrLen(mask)+2);
+  buf=MAlloc(mask_len+2);
   StrCpy(buf,mask);
-  dirc->mask=MAlloc(StrLen(mask)+2);
+
+  dirc->mask=MAlloc(mask_len+2);
   if (no_mask)
     *dirc->mask=0;
-  else
+  else if (StrOcc(buf,';')) {
+    semicolon_mask=MAlloc(mask_len+2);
+    StrCpy(semicolon_mask,mask);
+    StrFirstRem(semicolon_mask,";",buf);
     StrLastRem(buf,"/",dirc->mask);
+    CatPrint(dirc->mask,";%s",semicolon_mask);
+    Free(semicolon_mask);
+  } else
+    StrLastRem(buf,"/",dirc->mask);
+
   if (*mask=='/' && !*buf)
     StrCpy(buf,"/");
 //If began with Dir, change to Dir.

Kernel/BlkDev/DskDrv.CPP

@@ -74,7 +74,8 @@ U0 DrvFATBlkAlloc(CDrv *dv)
 
 U0 DrvFATBlkClean(CDrv *dv,I64 fat_select=3)
 {
-  if ((dv->type==DVT_FAT32 || dv->type==DVT_REDSEA)&&Bt(&dv->fat_blk_dirty,0)) {
+  if ((dv->fs_type==FSt_FAT32 || dv->fs_type==FSt_REDSEA) &&
+       Bt(&dv->fat_blk_dirty,0)) {
     if (dv->fat1==dv->fat2) {
       WBlks(dv,dv->cur_fat_blk,dv->fat1+dv->cur_fat_blk_num,1);
       LBtr(&dv->fat_blk_dirty,0);
@@ -94,11 +95,11 @@ U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_select=3)
   I64 fat_blk_num;
   if (c==INVALID_CLUSTER)
     throw('Drv');
-  switch (dv->type) {
-    case DVT_FAT32:
+  switch (dv->fs_type) {
+    case FSt_FAT32:
       fat_blk_num=c>>(BLK_SIZE_BITS-2);
       break;
-    case DVT_REDSEA:
+    case FSt_REDSEA:
       fat_blk_num=(c-dv->data_area)>>(BLK_SIZE_BITS+3);
       break;
     default:
@@ -114,10 +115,15 @@ U0 DrvFATBlkSet(CDrv *dv,I64 c,I64 fat_select=3)
   }
 }
 
-U0 DrvChk(CDrv *dv)
+CDrv *DrvChk(CDrv *dv,Bool except=TRUE)
 {//Check for valid drv. Throw exception.
-  if (!dv || dv->dv_signature!=DRV_SIGNATURE_VAL)
-    throw('Drv');
+  if (!dv || dv->dv_signature!=DRV_SIGNATURE_VAL) {
+    if (except)
+      throw('Drv');
+    else
+      return NULL;
+  } else
+    return dv;
 }
 
 U8 Drv2Let(CDrv *dv=NULL)
@@ -128,7 +134,19 @@ U8 Drv2Let(CDrv *dv=NULL)
   return dv->drv_let;
 }
 
-CDrv *Let2Drv(U8 drv_let=0)
+I64 Let2BlkDevType(U8 drv_let)
+{//Drv letter to BlkDev Type. drv_let=0 not allowed. See $LK,"BDT_NULL",A="MN:BDT_NULL"$.
+  drv_let=ToUpper(drv_let);
+  if ('A'<=drv_let<='B')
+    return BDT_RAM;
+  if ('C'<=drv_let<='S')
+    return BDT_ATA;
+  if ('T'<=drv_let<='Z')
+    return BDT_ATAPI;
+  return BDT_NULL;
+}
+
+CDrv *Let2Drv(U8 drv_let=0,Bool except=TRUE)
 {//Drv letter to Drv ptr.
   CDrv *dv;
   if (!drv_let)
@@ -137,21 +155,27 @@ CDrv *Let2Drv(U8 drv_let=0)
     if (drv_let==':')
       drv_let=blkdev.boot_drv_let;
     drv_let=ToUpper(drv_let);
-    if (!('A'<=drv_let<='Z'))
-      throw('Drv');
+    if (!('A'<=drv_let<='Z')) {
+      if (except)
+	throw('Drv');
+      else
+	return NULL;
+    }
     dv=blkdev.let_to_drv[drv_let-'A'];
   }
-  DrvChk(dv);
-  return dv;
+  return DrvChk(dv,except);
 }
 
-Bool DrvIsWritable(U8 drv_let=0)
+CBlkDev *DrvIsWritable(U8 drv_let=0,Bool except=FALSE)
 {//Is drive writable?
-  CBlkDev *bd=Let2BlkDev(drv_let);
-  if (bd->flags & BDF_READ_ONLY)
-    return FALSE;
-  else
-    return TRUE;
+  CBlkDev *bd;
+  if (!(bd=Let2BlkDev(drv_let,except)) || bd->flags & BDF_READ_ONLY) {
+    if (except)
+      throw('Drv');
+    else
+      return NULL;
+  } else
+    return bd;
 }
 
 U0 DskCacheInvalidate(CDrv *dv)
@@ -164,7 +188,7 @@ U0 DskCacheInvalidate(CDrv *dv)
     BlkDevInit(bd);
     if (bd->flags & BDF_READ_CACHE)
       DskCacheInvalidate2(dv);
-    if (dv->type==DVT_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
+    if (dv->fs_type==FSt_ISO9660 && !(bd->flags & BDF_READ_ONLY_OVERRIDE))
       ISODrvInit(dv,(32767/bd->blk_size+1)*bd->blk_size>>BLK_SIZE_BITS);
     if (unlock)
       DrvUnlock(dv);
@@ -199,8 +223,8 @@ Bool MapDrv(U8 drv_let,CDrv *dv)
 Bool Drv(U8 drv_let)
 {//Set drive.  You can set drive with $LK,"Cd",A="MN:Cd"$() as well.
   CDrv *dv=Let2Drv(drv_let);
-  CBlkDev *bd=dv->bd;
-  BlkDevChk(bd);
+  CBlkDev *bd;
+  bd=BlkDevChk(dv->bd);
   if (dv!=Fs->cur_dv) {
     if (bd->flags & BDF_REMOVABLE && !(bd->flags & BDF_INITIALIZED))
       ChgDsk(Drv2Let(dv));
@@ -210,10 +234,10 @@ Bool Drv(U8 drv_let)
   Fs->cur_dv=dv;
   Free(Fs->cur_dir);
   Fs->cur_dir=StrNew("/");
-  switch (dv->type) {
-    case DVT_REDSEA:
-    case DVT_FAT32:
-    case DVT_ISO9660:
+  switch (dv->fs_type) {
+    case FSt_REDSEA:
+    case FSt_FAT32:
+    case FSt_ISO9660:
       return TRUE;
     default:
       PrintErr("File System Not Supported\n");
@@ -251,35 +275,53 @@ U8 *DrvModelNum(U8 drv_let=0)
   return result;
 }
 
+U8 blkdev_text_attr[BDT_NUM_TYPES]={BLACK,LTCYAN,WHITE,LTBLUE};
+U8 drv_text_attr[3]={BLACK,BLUE,RED};
+
+U8 DrvTextAttrGet(U8 drv_let=0)
+{//Get color of drive.
+  if (!drv_let)
+    drv_let=Drv2Let(Fs->cur_dv);
+  else if (drv_let==':')
+    drv_let=blkdev.boot_drv_let;
+  drv_let=ToUpper(drv_let);
+  if ('A'<=drv_let<='Z')
+    return blkdev_text_attr[Let2BlkDevType(drv_let)]<<4|
+	  drv_text_attr[drv_let%sizeof(drv_text_attr)];
+  else
+    return BLACK<<4|WHITE;
+}
+
 U0 DrvRep()
 {//Drive report.
   CDrv *dv;
   CBlkDev *bd;
-  I64 i,drv_let;
+  I64 ch,i,drv_let,attr;
   U8 *st;
   "\nDefined Drives:\n\n";
   for (i=0,dv=blkdev.drvs;i<NUM_DRVS;i++,dv++) {
     if (dv->dv_signature==DRV_SIGNATURE_VAL) {
       bd=dv->bd;
       drv_let=Drv2Let(dv);
-      if (Bt(&dv->type,DVTf_DISABLE))
-	"$$RED$$X";
+      if (Bt(&dv->fs_type,FStf_DISABLE))
+	ch='-';
       else if (drv_let==blkdev.boot_drv_let)
-	"$$GREEN$$:";
+	ch=':';
       else
-	'' CH_SPACE;
-      "$$PURPLE$$%C %-8Z %-9Z %04X %04X %02X$$FG$$\n",
-	    drv_let,dv->type.u16[0],"ST_DRV_TYPES",
+	ch='+';
+      attr=DrvTextAttrGet(drv_let);
+      "$$FG,%d$$$$BG,%d$$%C %-8Z %-9Z %04X %04X %02X\n",
+	    attr&15,attr>>4,drv_let,dv->fs_type&FSG_TYPE_MASK,"ST_DRV_TYPES",
 	    bd->type,"ST_BLKDEV_TYPES",bd->base0,bd->base1,bd->unit;
       if (st=DrvModelNum(drv_let)) {
-	"   $$CYAN$$Model# :%s$$FG$$\n",st;
+	"   Model# :%s\n",st;
 	Free(st);
       }
       if (st=DrvSerialNum(drv_let)) {
-	"   $$CYAN$$Serial#:%s$$FG$$\n",st;
+	"   Serial#:%s\n",st;
 	Free(st);
       }
-      "   %016X-%016X\n",
+      "   %016X-%016X\n$$FG$$$$BG$$",
 	    dv->base_offset,dv->base_offset+dv->size-1;
       dv->base_offset,dv->base_offset+dv->size-1;
     }

Kernel/BlkDev/DskFile.CPP

@@ -21,16 +21,16 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
       else
 	curname=altname;
       if (dirc=DirContextNew(curname)) {
-	switch (dirc->dv->type) {
-	  case DVT_REDSEA:
+	switch (dirc->dv->fs_type) {
+	  case FSt_REDSEA:
 	    result=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
 		  &size,&attr);
 	    break;
-	  case DVT_FAT32:
+	  case FSt_FAT32:
 	    result=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
 		  &size,&attr);
 	    break;
-	  case DVT_ISO9660:
+	  case FSt_ISO9660:
 	    result=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
 		  &size,&attr);
 	    break;
@@ -50,16 +50,16 @@ U8 *FileRead(U8 *filename,I64 *_size=NULL,I64 *_attr=NULL)
       if (dirc=DirContextNew(curname)) {
 	while (!result && StrCmp(Fs->cur_dir,"/")) {
 	  Cd("..");
-	  switch (Fs->cur_dv->type) {
-	    case DVT_REDSEA:
+	  switch (Fs->cur_dv->fs_type) {
+	    case FSt_REDSEA:
 	      result=RedSeaFileRead(dirc->dv,Fs->cur_dir,dirc->mask,
 		    &size,&attr);
 	      break;
-	    case DVT_FAT32:
+	    case FSt_FAT32:
 	      result=FAT32FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
 		    &size,&attr);
 	      break;
-	    case DVT_ISO9660:
+	    case FSt_ISO9660:
 	      result=ISO1FileRead(dirc->dv,Fs->cur_dir,dirc->mask,
 		    &size,&attr);
 	      break;
@@ -106,16 +106,16 @@ I64 FileWrite(U8 *filename,U8 *fbuf,I64 size,CDate cdt=0,I64 attr=0)
     } else
       fbuf2=NULL;
     if (!cdt) cdt=Now;
-    switch (dirc->dv->type) {
-      case DVT_REDSEA:
+    switch (dirc->dv->fs_type) {
+      case FSt_REDSEA:
 	c=RedSeaFileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
 	      size,cdt,attr);
 	break;
-      case DVT_FAT32:
+      case FSt_FAT32:
 	c=FAT32FileWrite(dirc->dv,Fs->cur_dir,dirc->mask,fbuf,
 	      size,cdt,attr);
 	break;
-      case DVT_ISO9660:
+      case FSt_ISO9660:
 	PrintErr("Not Writable\n");
 	break;
       default:

Kernel/BlkDev/DskFind.CPP

@@ -3,14 +3,14 @@ CDirEntry *FilesFind2(U8 *files_find_mask,I64 fuf_flags)
   CDrv *dv=Fs->cur_dv;
   CDirEntry *result=NULL;
   DrvChk(dv);
-  switch (dv->type) {
-    case DVT_REDSEA:
+  switch (dv->fs_type) {
+    case FSt_REDSEA:
       result=RedSeaFilesFind(files_find_mask,fuf_flags);
       break;
-    case DVT_FAT32:
+    case FSt_FAT32:
       result=FAT32FilesFind(files_find_mask,fuf_flags);
       break;
-    case DVT_ISO9660:
+    case FSt_ISO9660:
       result=ISO1FilesFind(files_find_mask,fuf_flags);
       break;
     default:
@@ -64,7 +64,8 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
   Bool result=FALSE,old_silent;
   if (fuf_flags&~FUG_FILE_FIND)
     throw('FUF');
-  if (!filename) return FALSE;
+  if (!filename || *filename && filename[1]==':' && !Let2Drv(*filename,FALSE))
+    return FALSE;
   altname=ToggleZorNotZ(filename);
   if (fuf_flags&FUF_Z_OR_NOT_Z)
     j=2;
@@ -81,16 +82,16 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
     else {
       Silent(old_silent);
       cur_dir_cluster=Name2DirCluster(dirc->dv,Fs->cur_dir);
-      switch (dirc->dv->type) {
-	case DVT_REDSEA:
+      switch (dirc->dv->fs_type) {
+	case FSt_REDSEA:
 	  result=RedSeaFileFind(dirc->dv,cur_dir_cluster,dirc->mask,
 		&de,fuf_flags);
 	  break;
-	case DVT_FAT32:
+	case FSt_FAT32:
 	  result=FAT32FileFind(dirc->dv,cur_dir_cluster,dirc->mask,
 		&de,fuf_flags);
 	  break;
-	case DVT_ISO9660:
+	case FSt_ISO9660:
 	  result=ISO1FileFind(dirc->dv,cur_dir_cluster,dirc->mask,
 		&de,fuf_flags);
 	  break;
@@ -121,16 +122,16 @@ Bool FileFind(U8 *filename,CDirEntry *_de=NULL,I64 fuf_flags=0)
       while (!result && StrCmp(Fs->cur_dir,"/")) {
 	Cd("..");
 	cur_dir_cluster=Name2DirCluster(dirc->dv,Fs->cur_dir);
-	switch (dirc->dv->type) {
-	  case DVT_REDSEA:
+	switch (dirc->dv->fs_type) {
+	  case FSt_REDSEA:
 	    result=RedSeaFileFind(dirc->dv,cur_dir_cluster,
 		  dirc->mask,&de,fuf_flags);
 	    break;
-	  case DVT_FAT32:
+	  case FSt_FAT32:
 	    result=FAT32FileFind(dirc->dv,cur_dir_cluster,
 		  dirc->mask,&de,fuf_flags);
 	    break;
-	  case DVT_ISO9660:
+	  case FSt_ISO9660:
 	    result=ISO1FileFind(dirc->dv,cur_dir_cluster,
 		  dirc->mask,&de,fuf_flags);
 	    break;

Kernel/BlkDev/DskFmt.CPP

@@ -1,4 +1,4 @@
-Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
+Bool DrvTypeSet(U8 drv_let,I64 type=FSt_REDSEA)
 {//Very dangerous
   I64 i,j,ext_base,drv_num,offset,cur_type;
   CMasterBoot mbr;
@@ -19,10 +19,10 @@ Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
 	    else {
 	      if (drv_num+'A'==ToUpper(drv_let)) {
 		switch (type) {
-		  case DVT_REDSEA:
+		  case FSt_REDSEA:
 		    mbr.p[i].type=MBR_PT_REDSEA;
 		    break;
-		  case DVT_FAT32:
+		  case FSt_FAT32:
 		    mbr.p[i].type=MBR_PT_FAT32a;
 		    break;
 		  default:
@@ -50,11 +50,11 @@ Bool DrvTypeSet(U8 drv_let,I64 type=DVT_REDSEA)
   }
 }
 
-U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
+U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=FSt_FAT32)
 {//Format hard drive or RAM drive.
 //$BK,1$Warning:$BK,0$ Destroys all previous info.
   //quick=FALSE means fill entire drive with zeros.
-  //Choose $LK,"DVT_FAT32",A="MN:DVT_FAT32"$ or $LK,"DVT_REDSEA",A="MN:DVT_REDSEA"$.
+  //Choose $LK,"FSt_FAT32",A="MN:FSt_FAT32"$ or $LK,"FSt_REDSEA",A="MN:FSt_REDSEA"$.
   //You don't format a CD/DVD with this.
   CDrv *dv=Let2Drv(drv_let);
   Bool old_silent=IsSilent;
@@ -65,7 +65,7 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
     return;
   }
   switch (type) {
-    case DVT_REDSEA:
+    case FSt_REDSEA:
       Silent;
       Drv(drv_let);
       Silent(old_silent);
@@ -73,7 +73,7 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
       DskCacheInvalidate(Let2Drv(drv_let));
       Drv(drv_let);
       break;
-    case DVT_FAT32:
+    case FSt_FAT32:
       Silent;
       Drv(drv_let);
       Silent(old_silent);
@@ -81,7 +81,7 @@ U0 Fmt(I64 drv_let,Bool quick=TRUE,Bool confirm=TRUE,I64 type=DVT_FAT32)
       DskCacheInvalidate(Let2Drv(drv_let));
       Drv(drv_let);
       break;
-    case DVT_ISO9660:
+    case FSt_ISO9660:
       PrintErr("Not Writable\n");
       break;
     default:

Kernel/BlkDev/DskStrA.CPP

@@ -37,39 +37,54 @@ Bool IsDotC(U8 *filename)
     return FALSE;
 }
 
-Bool FilesFindMatch(U8 *test_filename,U8 *files_find_mask,I64 fuf_flags=0)
+Bool FilesFindMatch(U8 *_test_name,U8 *files_find_mask,I64 fuf_flags=0)
 {//Does filename meet $LK,"Files Find",A="FI:::/Doc/FileUtils.TXT"$ mask?
-  U8 *st1=StrNew(files_find_mask),
-	*st2=MAlloc(StrLen(files_find_mask)+1);
+  I64 tn_len=StrLen(_test_name),mask_len=StrLen(files_find_mask);
+  U8 *mask1=MAlloc(mask_len+1),*mask2=MAlloc(mask_len+1),
+	*ptr,*test_name1,*test_name2;
   Bool result=FALSE;
+  StrCpy(mask1,files_find_mask);
+  if (StrOcc(_test_name,'/')) {
+    test_name1=MAlloc(tn_len+1);
+    test_name2=MAlloc(tn_len+1);
+    StrCpy(test_name1,_test_name);
+    StrLastRem(test_name1,"/",test_name2);
+  } else {
+    test_name1=NULL;
+    test_name2=NULL;
+  }
   while (TRUE) {
-    StrFirstRem(st1,";",st2);
-    if (*st2) {
-      if (*st2=='~') {
-	if (WildMatch(test_filename,st2+1)) {
+    StrFirstRem(mask1,";",mask2);
+    if (!test_name2 || StrOcc(mask2,'/'))
+      ptr=_test_name;
+    else
+      ptr=test_name2;
+    if (*mask2) {
+      if (*mask2=='~') {
+	if (WildMatch(ptr,mask2+1)) {
 	  result=FALSE;
 	  break;
 	}
       } else {
-	if (WildMatch(test_filename,st2)) {
+	if (WildMatch(ptr,mask2)) {
 	  if (Bt(&fuf_flags,FUf_JUST_TXT) &&
-		!FilesFindMatch(test_filename,FILEMASK_TXT)) {
+		!FilesFindMatch(_test_name,FILEMASK_TXT)) {
 	    result=FALSE;
 	    break;
 	  } else if (Bt(&fuf_flags,FUf_JUST_SRC) &&
-		!FilesFindMatch(test_filename,FILEMASK_SRC)) {
+		!FilesFindMatch(_test_name,FILEMASK_SRC)) {
 	    result=FALSE;
 	    break;
 	  } else if (Bt(&fuf_flags,FUf_JUST_AOT) &&
-		!FilesFindMatch(test_filename,FILEMASK_AOT)) {
+		!FilesFindMatch(_test_name,FILEMASK_AOT)) {
 	    result=FALSE;
 	    break;
 	  } else if (Bt(&fuf_flags,FUf_JUST_JIT) &&
-		!FilesFindMatch(test_filename,FILEMASK_JIT)) {
+		!FilesFindMatch(_test_name,FILEMASK_JIT)) {
 	    result=FALSE;
 	    break;
 	  } else if (Bt(&fuf_flags,FUf_JUST_GRA) &&
-		!FilesFindMatch(test_filename,FILEMASK_GRA)) {
+		!FilesFindMatch(_test_name,FILEMASK_GRA)) {
 	    result=FALSE;
 	    break;
 	  } else
@@ -79,8 +94,10 @@ Bool FilesFindMatch(U8 *test_filename,U8 *files_find_mask,I64 fuf_flags=0)
     } else
       break;
   }
-  Free(st1);
-  Free(st2);
+  Free(test_name1);
+  Free(test_name2);
+  Free(mask1);
+  Free(mask2);
   return result;
 }
 

Kernel/BlkDev/DskStrB.CPP

@@ -20,14 +20,14 @@ I64 Name2DirCluster(CDrv *dv,U8 *dirname)
     while (*buf && cont) {
       StrFirstRem(buf,"/",buf2);
       if (*buf2) {
-	switch (dv->type) {
-	  case DVT_REDSEA:
+	switch (dv->fs_type) {
+	  case FSt_REDSEA:
 	    cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
 	    break;
-	  case DVT_FAT32:
+	  case FSt_FAT32:
 	    cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
 	    break;
-	  case DVT_ISO9660:
+	  case FSt_ISO9660:
 	    cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
 	    break;
 	  default:
@@ -65,14 +65,14 @@ I64 Name2ParentDirCluster(CDrv *dv,U8 *dirname)
       cur_dir_cluster2=cur_dir_cluster;
       StrFirstRem(buf,"/",buf2);
       if (*buf2) {
-	switch (dv->type) {
-	  case DVT_REDSEA:
+	switch (dv->fs_type) {
+	  case FSt_REDSEA:
 	    cont=RedSeaFileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
 	    break;
-	  case DVT_FAT32:
+	  case FSt_FAT32:
 	    cont=FAT32FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
 	    break;
-	  case DVT_ISO9660:
+	  case FSt_ISO9660:
 	    cont=ISO1FileFind(dv,cur_dir_cluster,buf2,&de,FUF_JUST_DIRS);
 	    break;
 	  default:

Kernel/BlkDev/FileSysFAT.CPP

@@ -25,7 +25,7 @@ U0 FAT32DrvInit(CDrv *dv)
   Bool unlock;
   try {
     unlock=DrvLock(dv);
-    dv->type=DVT_FAT32;
+    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;
@@ -49,17 +49,12 @@ Bool FAT32DrvValidate(U8 drv_let)
 {
   CDrv *dv;
   CFAT32Boot br;
-  Bool result=FALSE;
-  try {
-    dv=Let2Drv(drv_let);
-    if (dv->type==DVT_FAT32 &&
-	  RBlks(dv,&br,dv->base_offset,1) &&
-	  br.signature==0xAA55 &&
-	  br.sects==dv->size)
-      result=TRUE;
-  } catch
-    Fs->catch_except=TRUE;
-  return result;
+  if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_FAT32 &&
+	RBlks(dv,&br,dv->base_offset,1) && br.signature==0xAA55 &&
+	br.sects==dv->size)
+    return TRUE;
+  else
+    return FALSE;
 }
 
 U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
@@ -70,8 +65,8 @@ U0 FAT32Fmt(U8 drv_let,Bool quick=TRUE)
   I64 i,l;
   try {
     DrvLock(dv);
-    DrvTypeSet(drv_let,DVT_FAT32);
-    dv->type=DVT_FAT32;
+    DrvTypeSet(drv_let,FSt_FAT32);
+    dv->fs_type=FSt_FAT32;
     br->jump_and_nop[0]=OC_JMP_REL8;
     br->jump_and_nop[1]=offset(CFAT32Boot.code)-2;
     br->jump_and_nop[2]=OC_NOP;
@@ -313,7 +308,7 @@ Bool FAT32FileFind(CDrv *dv,I64 cur_dir_cluster,
   MemSet(_result,0,sizeof(CDirEntry));
   MemSet(&long_name,0,sizeof(CDirEntry));
   DrvChk(dv);
-  if (dv->type!=DVT_FAT32)
+  if (dv->fs_type!=FSt_FAT32)
     PrintErr("Not FAT32 Drv\n");
   else if (!CFileNameTo(dname,name))
     PrintErr("Invalid FileName.\n");
@@ -377,7 +372,7 @@ U8 *FAT32FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
   DrvChk(dv);
   *_size=0;
   *_attr=0;
-  if (dv->type!=DVT_FAT32)
+  if (dv->fs_type!=FSt_FAT32)
     PrintErr("Not FAT32 Drv\n");
   else
     try {
@@ -404,7 +399,7 @@ U8 *FAT32FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
 Bool FAT32Cd(U8 *name,I64 cur_dir_cluster)
 {
   CDirEntry de;
-  if (Fs->cur_dv->type!=DVT_FAT32)
+  if (Fs->cur_dv->fs_type!=FSt_FAT32)
     PrintErr("Not FAT32 Drv\n");
   else if (FAT32FileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
     return TRUE;
@@ -421,7 +416,7 @@ U0 FAT32FreeClusters(CDrv *dv,I64 c)
   Bool unlock,unlock_break;
   DrvChk(dv);
   if (!(0<c<0x0FFFFFF8)) return;
-  if (dv->type!=DVT_FAT32)
+  if (dv->fs_type!=FSt_FAT32)
     PrintErr("Not FAT32 Drv\n");
   else
     try {
@@ -823,7 +818,7 @@ I64 FAT32FileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
   Bool contiguous;
   MemSet(&de,0,sizeof(CDirEntry));
   if (size<0) size=0;
-  if (dv->type!=DVT_FAT32)
+  if (dv->fs_type!=FSt_FAT32)
     PrintErr("Not FAT32 Drv\n");
   else if (!CFileNameTo(de.name,name))
     PrintErr("Invalid FileName.\n");
@@ -896,15 +891,18 @@ CDirEntry *FAT32FilesFind(U8 *files_find_mask,
 		  Cd("..");
 		}
 		DrvLock(dv);
-	      } else if ((attr&RS_ATTR_DIR || !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
-		    !(Bt(&fuf_flags,FUf_RECURSE) &&
-		    *tempde->name=='.' && attr&RS_ATTR_DIR) &&
-		    FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
-		tempde->next=result;
-		result=tempde;
+	      } else {
 		tempde->full_name=FileNameAbs(tempde->name);
-	      } else
-		DirEntryDel(tempde);
+		if ((attr&RS_ATTR_DIR || !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
+		      !(Bt(&fuf_flags,FUf_RECURSE) &&
+		      *tempde->name=='.' && attr&RS_ATTR_DIR) &&
+		      FilesFindMatch(tempde->full_name,files_find_mask,
+		      fuf_flags)) {
+		  tempde->next=result;
+		  result=tempde;
+		} else
+		  DirEntryDel(tempde);
+	      }
 	    } else
 	      DirEntryDel(tempde);
 	  }

Kernel/BlkDev/FileSysISO.CPP

@@ -13,7 +13,7 @@ Bool ISODrvInit(CDrv *dv,I64 blk)
 
   try {
     unlock=DrvLock(dv);
-    dv->type=DVT_ISO9660; //default
+    dv->fs_type=FSt_ISO9660; //default
     dv->spc=spc;
     dv->base_offset=dv->data_area=dv->root_cluster=dv->size=0;
     while (TRUE) {
@@ -24,7 +24,7 @@ Bool ISODrvInit(CDrv *dv,I64 blk)
       switch (LstMatch(buf,"CD001\0CDW02\0BEA01\0BOOT2\0NSR02\0NSR03\0TEA01\0",
 	    LMF_EXACT)) {
 	case 0:
-	  dv->type=DVT_ISO9660;
+	  dv->fs_type=FSt_ISO9660;
 	  switch (iso->type) {
 	    case ISO1T_SUPPLEMENTARY_DESC:
 	      dv->data_area=0;
@@ -48,7 +48,7 @@ ipi_done:
     if (unlock)
       DrvUnlock(dv);
   } catch {
-    dv->type=DVT_ISO9660;
+    dv->fs_type=FSt_ISO9660;
     dv->spc=spc;
     dv->base_offset=dv->data_area=dv->root_cluster=0;
     Free(iso);
@@ -137,7 +137,7 @@ Bool ISO1FileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
   if (fuf_flags&~FUG_FILE_FIND)
     throw('FUF');
   DrvChk(dv);
-  if (dv->type!=DVT_ISO9660)
+  if (dv->fs_type!=FSt_ISO9660)
     PrintErr("Not ISO9660 Drv\n");
   else
     try {
@@ -195,7 +195,7 @@ U8 *ISO1FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
   DrvChk(dv);
   *_size=0;
   *_attr=0;
-  if (dv->type!=DVT_ISO9660)
+  if (dv->fs_type!=FSt_ISO9660)
     PrintErr("Not ISO9660 Drv\n");
   else
     try {
@@ -219,7 +219,7 @@ U8 *ISO1FileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
 Bool ISO1Cd(U8 *name,I64 cur_dir_cluster)
 {
   CDirEntry de;
-  if (Fs->cur_dv->type!=DVT_ISO9660)
+  if (Fs->cur_dv->fs_type!=FSt_ISO9660)
     PrintErr("Not ISO9660 Drv\n");
   else if (ISO1FileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
     return TRUE;
@@ -269,16 +269,18 @@ CDirEntry *ISO1FilesFind(U8 *files_find_mask,
 	    tempde->sub=ISO1FilesFind(files_find_mask,fuf_flags,tempde);
 	    Cd("..");
 	  }
-	} else if ((tempde->attr & RS_ATTR_DIR ||
-	      !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
-	      !(Bt(&fuf_flags,FUf_RECURSE) &&
-	      *tempde->name=='.' && tempde->attr&RS_ATTR_DIR) &&
-	      FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
-	  tempde->next=result;
-	  result=tempde;
+	} else {
 	  tempde->full_name=FileNameAbs(tempde->name);
-	} else
-	  DirEntryDel(tempde);
+	  if ((tempde->attr & RS_ATTR_DIR ||
+		!Bt(&fuf_flags,FUf_JUST_DIRS)) &&
+		!(Bt(&fuf_flags,FUf_RECURSE) &&
+		*tempde->name=='.' && tempde->attr&RS_ATTR_DIR) &&
+		FilesFindMatch(tempde->full_name,files_find_mask,fuf_flags)) {
+	    tempde->next=result;
+	    result=tempde;
+	  } else
+	    DirEntryDel(tempde);
+	}
       } else
 	DirEntryDel(tempde);
       i-=buf->len;

Kernel/BlkDev/FileSysRedSea.CPP

@@ -64,7 +64,7 @@ U0 RedSeaDrvInit(CDrv *dv)
     RBlks(dv,&br,dv->base_offset,1);
     if (br.signature!=MBR_PT_REDSEA || br.signature2!=0xAA55)
       throw('Drv');
-    dv->type=DVT_REDSEA;
+    dv->fs_type=FSt_REDSEA;
     RedSeaFreeFreeLst(dv);
     dv->spc=1;
     dv->size=br.sects;
@@ -83,16 +83,12 @@ Bool RedSeaDrvValidate(U8 drv_let)
 {
   CDrv *dv;
   CRedSeaBoot br;
-  Bool result=FALSE;
-  try {
-    dv=Let2Drv(drv_let);
-    if (dv->type==DVT_REDSEA && RBlks(dv,&br,dv->base_offset,1) &&
-	  br.signature==MBR_PT_REDSEA && br.signature2==0xAA55 &&
-	  br.sects==dv->size)
-      result=TRUE;
-  } catch
-    Fs->catch_except=TRUE;
-  return result;
+  if ((dv=Let2Drv(drv_let,FALSE)) && dv->fs_type==FSt_REDSEA &&
+	RBlks(dv,&br,dv->base_offset,1) && br.signature==MBR_PT_REDSEA &&
+	br.signature2==0xAA55 && br.sects==dv->size)
+    return TRUE;
+  else
+    return FALSE;
 }
 
 U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
@@ -104,9 +100,9 @@ U0 RedSeaFmt(U8 drv_let,Bool quick=TRUE)
   I64 i,n;
   try {
     DrvLock(dv);
-//	DrvTypeSet(drv_let,DVT_REDSEA);
-    DrvTypeSet(drv_let,DVT_FAT32);
-    dv->type=DVT_REDSEA;
+//	DrvTypeSet(drv_let,FSt_REDSEA);
+    DrvTypeSet(drv_let,FSt_FAT32);
+    dv->fs_type=FSt_REDSEA;
     br->signature=MBR_PT_REDSEA;
     br->signature2=0xAA55;
     br->base_offset=dv->base_offset; //For CD/DVD image copy.
@@ -165,7 +161,7 @@ Bool RedSeaFileFind(CDrv *dv,I64 cur_dir_cluster,U8 *name,
     throw('FUF');
   MemSet(_result,0,sizeof(CDirEntry));
   DrvChk(dv);
-  if (dv->type!=DVT_REDSEA)
+  if (dv->fs_type!=FSt_REDSEA)
     PrintErr("Not RedSea Drv\n");
   else if (!CFileNameTo(dname,name))
     PrintErr("Invalid FileName.\n");
@@ -214,7 +210,7 @@ U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
   DrvChk(dv);
   *_size=0;
   *_attr=0;
-  if (dv->type!=DVT_REDSEA)
+  if (dv->fs_type!=FSt_REDSEA)
     PrintErr("Not RedSea Drv\n");
   else
     try {
@@ -238,7 +234,7 @@ U8 *RedSeaFileRead(CDrv *dv,U8 *cur_dir,U8 *filename,I64 *_size,I64 *_attr)
 Bool RedSeaCd(U8 *name,I64 cur_dir_cluster)
 {
   CDirEntry de;
-  if (Fs->cur_dv->type!=DVT_REDSEA)
+  if (Fs->cur_dv->fs_type!=FSt_REDSEA)
     PrintErr("Not RedSea Drv\n");
   else if (RedSeaFileFind(Fs->cur_dv,cur_dir_cluster,name,&de,FUF_JUST_DIRS))
     return TRUE;
@@ -255,7 +251,7 @@ U0 RedSeaFreeClusters(CDrv *dv,I64 c,I64 cnt)
   Bool found=FALSE,unlock,unlock_break;
   DrvChk(dv);
   if (!c) return;
-  if (dv->type!=DVT_REDSEA)
+  if (dv->fs_type!=FSt_REDSEA)
     PrintErr("Not RedSea Drv\n");
   else
     try {
@@ -517,7 +513,7 @@ I64 RedSeaFileWrite(CDrv *dv,U8 *cur_dir,U8 *name,U8 *buf,I64 size,
   I64 c=0,blk_cnt;
   MemSet(&de,0,sizeof(CDirEntry));
   if (size<0) size=0;
-  if (dv->type!=DVT_REDSEA)
+  if (dv->fs_type!=FSt_REDSEA)
     PrintErr("Not RedSea Drv\n");
   else if (!CFileNameTo(de.name,name))
     PrintErr("Invalid FileName.\n");
@@ -581,16 +577,18 @@ CDirEntry *RedSeaFilesFind(U8 *files_find_mask,I64 fuf_flags,
 	    Cd("..");
 	  }
 	  DrvLock(dv);
-	} else if ((tempde->attr&RS_ATTR_DIR ||
-	      !Bt(&fuf_flags,FUf_JUST_DIRS)) &&
-	      !(Bt(&fuf_flags,FUf_RECURSE) && *tempde->name=='.' &&
-	      tempde->attr&RS_ATTR_DIR) &&
-	      FilesFindMatch(tempde->name,files_find_mask,fuf_flags)) {
-	  tempde->next=result;
-	  result=tempde;
+	} else {
 	  tempde->full_name=FileNameAbs(tempde->name);
-	} else
-	  DirEntryDel(tempde);
+	  if ((tempde->attr&RS_ATTR_DIR ||
+		!Bt(&fuf_flags,FUf_JUST_DIRS)) &&
+		!(Bt(&fuf_flags,FUf_RECURSE) && *tempde->name=='.' &&
+		tempde->attr&RS_ATTR_DIR) &&
+		FilesFindMatch(tempde->full_name,files_find_mask,fuf_flags)) {
+	    tempde->next=result;
+	    result=tempde;
+	  } else
+	    DirEntryDel(tempde);
+	}
       }
       ptr(U8 *)+=CDIR_SIZE;
     }