Nightly update (ISO SHA-1 29c437f)

TempleOSCD/Adam/ABlkDev/ADskA.HC

@@ -6,34 +6,34 @@ public U8 *DBlk(I64 blk,Bool write=FALSE)
   //See $LK,"::/Demo/Dsk/DskRaw.HC"$.
   U8 *buf=MAlloc(BLK_SIZE);
 
-  RBlks(Fs->cur_dv,buf,blk,1);
+  BlkRead(Fs->cur_dv,buf,blk,1);
   DocD(buf,BLK_SIZE);
   if (write) {
     "Edit and press <ESC> to write or <SHIFT-ESC>\n";
     if (View) {
       "Write\n";
-      WBlks(Fs->cur_dv,buf,blk,1);
+      BlkWrite(Fs->cur_dv,buf,blk,1);
     }
   }
   return buf;
 }
 
-public U8 *DCluster(I64 c,Bool write=FALSE,I64 num=0)
-{//Dump disk cluster. Optionally, write.
-//If you set write to TRUE, the cluster will
+public U8 *DClus(I64 c,Bool write=FALSE,I64 num=0)
+{//Dump disk clus. Optionally, write.
+//If you set write to TRUE, the clus will
   //be written when you press <ESC>.
   //See $LK,"::/Demo/Dsk/DskRaw.HC"$.
-  //Do $LK,"Dir",A="MN:Dir"$("*",TRUE); to get cluster numbers of files.
+  //Do $LK,"Dir",A="MN:Dir"$("*",TRUE); to get clus numbers of files.
   U8 *buf=MAlloc(Fs->cur_dv->spc<<BLK_SIZE_BITS);
-  c=ClusterNumNext(Fs->cur_dv,c,num);
-  RClusters(Fs->cur_dv,buf,c,1);
-  "Cluster:%X\n",c;
+  c=ClusNumNext(Fs->cur_dv,c,num);
+  ClusRead(Fs->cur_dv,buf,c,1);
+  "Clus:%X\n",c;
   DocD(buf,Fs->cur_dv->spc<<BLK_SIZE_BITS);
   if (write) {
     "Edit and press <ESC> to write or <SHIFT-ESC>\n";
     if (View) {
       "Write\n";
-      WClusters(Fs->cur_dv,buf,c,1);
+      ClusWrite(Fs->cur_dv,buf,c,1);
     }
   }
   return buf;
@@ -67,7 +67,7 @@ public Bool Copy(U8 *src_files_find_mask,U8 *dst_files_find_mask=".")
   CDirContext *dirc;
   CDirEntry *tmpde,*tmpde1;
   U8 *st;
-  if (!(tmpde1=FilesFind(src_files_find_mask,FUF_CLUSTER_ORDER)))
+  if (!(tmpde1=FilesFind(src_files_find_mask,FUF_CLUS_ORDER)))
     return FALSE;
   if (IsDir(dst_files_find_mask)) {
     if (dirc=DirContextNew(dst_files_find_mask,TRUE)) {
@@ -109,7 +109,7 @@ I64 CopyTree2(CDirEntry *tmpde,I64 src_dir_len,I64 dst_dir_len,U8 *dst_dir)
     MemCpy(st,dst_dir,dst_dir_len);
     StrCpy(st+dst_dir_len,tmpde->full_name+src_dir_len);
     if (tmpde->attr & RS_ATTR_DIR) {
-      MkDir(st,LinkedLstCnt(tmpde->sub));
+      DirMk(st,LinkedLstCnt(tmpde->sub));
       res+=CopyTree2(tmpde->sub,src_dir_len,dst_dir_len,dst_dir);
     } else
       if (CopySingle(tmpde->full_name,st))
@@ -140,12 +140,12 @@ public I64 CopyTree(U8 *src_files_find_mask,U8 *dst_files_find_mask,
   Free(st2);
   if (dirc=DirContextNew(src_files_find_mask,TRUE,,no_mask)) {
     tmpde=FilesFind(dirc->mask,FUF_RECURSE);
-    st1=CurDir;
+    st1=DirCur;
     DirContextDel(dirc);
     i1=StrLen(st1);
     if (i1==3) i1--;
     if (dirc=DirContextNew(dst_files_find_mask,TRUE,TRUE)) {
-      st2=CurDir;
+      st2=DirCur;
       i2=StrLen(st2);
       if (i2==3) i2--;
       res=CopyTree2(tmpde,i1,i2,st2);

TempleOSCD/Adam/ABlkDev/ADskB.HC

@@ -87,7 +87,7 @@ I64 Size1(CDirEntry *tmpde,I64 *_fuf_flags,I64 round_to)
 	  !(tmpde->attr&RS_ATTR_DIR) &&
 	  FileAttr(tmpde->name)&RS_ATTR_COMPRESSED) {
       dv=Let2Drv(*tmpde->full_name);
-      RBlks(dv,buf,Cluster2Blk(dv,tmpde->cluster),1);
+      BlkRead(dv,buf,Clus2Blk(dv,tmpde->clus),1);
       i=(&buf)(CArcCompress *)->expanded_size;
     }
     if (round_to)

TempleOSCD/Adam/ABlkDev/DskChk.HC

@@ -0,0 +1,444 @@
+#help_index "Info;File/Cmd Line (Typically);Cmd Line (Typically)"
+Bool ChkDskConfirm(Bool *_fix,Bool *_confirm)
+{
+  if (*_fix && *_confirm) {
+    "Fix ";
+    if (!YorN)
+      *_fix=FALSE;
+    *_confirm=FALSE;
+  }
+  return *_fix;
+}
+
+I64 RedSeaChkDskLst(CDrv *dv,CDirEntry *tmpde1,
+	U8 *bits,U8 *bits2,I64 size,I64 bpc)
+{
+  CDirEntry *tmpde2;
+  I64 i,j,errs=0;
+  while (tmpde1) {
+    tmpde2=tmpde1->next;
+    if (tmpde1->attr & RS_ATTR_DIR && tmpde1->sub)
+      errs+=RedSeaChkDskLst(dv,tmpde1->sub,bits,bits2,size,bpc);
+    j=(tmpde1->size+bpc-1)/bpc;
+    for (i=0;i<j;i++) {
+      if (i+tmpde1->clus-dv->data_area>size) {
+	PrintErr("Invalid Clus:%s Clus:%X\n",tmpde1->full_name,
+	      i+tmpde1->clus);
+	errs++;
+	break;
+      }
+      if (LBts(bits,i+tmpde1->clus-dv->data_area)) {
+	PrintErr("Dbl Alloc:%s Clus:%X\n",tmpde1->full_name,
+	      i+tmpde1->clus);
+	errs++;
+      }
+      if (!LBtr(bits2,i+tmpde1->clus-dv->data_area)) {
+	PrintErr("UnAlloc:%s Clus:%X\n",tmpde1->full_name,
+	      i+tmpde1->clus);
+	errs++;
+      }
+    }
+    DirEntryDel(tmpde1);
+    tmpde1=tmpde2;
+  }
+  return errs;
+}
+
+I64 RedSeaChkDsk(U8 drv_let,Bool *_fix,Bool *_confirm)
+{
+  I64 i,j,bpc,size,errs=0;
+  CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
+  U8 *files_find_mask=MStrPrint("%c:/*",Drv2Let(dv)),
+	*old_dir=StrNew(Fs->cur_dir),
+	*bits,*bits2;
+  CDirEntry *ptr,*ptr2;
+
+  Drv(drv_let);
+  "Scanning...\n";
+  size=(dv->size-(dv->data_area-dv->drv_offset))/dv->spc;
+  bpc=dv->spc<<BLK_SIZE_BITS;
+  bits=CAlloc((size+7)>>3);
+  bits2=CAlloc((size+7)>>3+BLK_SIZE);
+  BlkRead(dv,bits2,dv->fat1,((size+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS);
+
+  //Get Root Dir size
+  ptr2=MAlloc(bpc);
+  BlkRead(dv,ptr2,dv->root_clus,1);
+  ptr=ptr2(U8 *)-offset(CDirEntry.start);
+  j=(ptr->size+bpc-1)/bpc;
+  Free(ptr2);
+
+  for (i=0;i<j;i++) {
+    if (i+dv->root_clus-dv->data_area>size) {
+      PrintErr("Invalid Clus: RootDir Clus:%X\n",i+dv->root_clus);
+      errs++;
+      break;
+    }
+    if (LBts(bits,i+dv->root_clus-dv->data_area)) {
+      PrintErr("Dbl Alloc: RootDir Clus:%X\n",i+dv->root_clus);
+      errs++;
+    }
+    if (!LBtr(bits2,i+dv->root_clus-dv->data_area)) {
+      PrintErr("UnAlloc: RootDir Clus:%X\n",i+dv->root_clus);
+      errs++;
+    }
+  }
+
+  errs+=RedSeaChkDskLst(dv,FilesFind(files_find_mask,FUF_RECURSE),
+	bits,bits2,size,bpc);
+  for (i=1;i<size;i++)
+    if (Bt(bits2,i)) {
+      PrintWarn("Shouldn't Alloc Clus:%0X\n",i+dv->data_area);
+      errs++;
+      if (ChkDskConfirm(_fix,_confirm))
+	RedSeaFreeClus(dv,i+dv->data_area,1);
+    }
+
+  Free(files_find_mask);
+  Free(bits);
+  Free(bits2);
+  Drv(Drv2Let(old_dv));
+  Cd(old_dir);
+  Free(old_dir);
+  return errs;
+}
+
+I64 FAT32ChkDskLst(CDrv *dv,CDirEntry *tmpde1,
+	U8 *bits,U32 *bits2,I64 size,I64 bpc)
+{
+  CDirEntry *tmpde2;
+  I64 i,c,errs=0;
+  while (tmpde1) {
+    tmpde2=tmpde1->next;
+    if (tmpde1->attr & RS_ATTR_DIR && tmpde1->sub)
+      errs+=FAT32ChkDskLst(dv,tmpde1->sub,bits,bits2,size,bpc);
+    i=0;
+    c=tmpde1->clus;
+    while (0<c<0x0FFFFFF8) {
+      if (c>size) {
+	PrintErr("Invalid Clus:%s Clus:%X\n",tmpde1->full_name,c);
+	errs++;
+	break;
+      }
+      if (LBts(bits,c)) {
+	PrintErr("Dbl Alloc:%s Clus:%X\n",tmpde1->full_name,c);
+	errs++;
+      }
+      if (!bits2[c]) {
+	PrintErr("UnAlloc:%s Clus:%X\n",tmpde1->full_name,c);
+	errs++;
+      } else
+	bits2[c]=0;
+      c=ClusNumNext(dv,c);
+      i++;
+    }
+    if (!(tmpde1->attr & RS_ATTR_DIR)) {
+      i*=bpc;
+      if (tmpde1->size>i) {
+	PrintErr("Alloced File Too Short:%s\n",tmpde1->full_name);
+	errs++;
+      }
+      if (i>tmpde1->size+bpc-1) {
+	PrintWarn("Alloced File Too Long:%s\n",tmpde1->full_name);
+	errs++;
+      }
+    }
+    DirEntryDel(tmpde1);
+    tmpde1=tmpde2;
+  }
+  return errs;
+}
+
+I64 FAT32ChkDsk(U8 drv_let,Bool *_fix,Bool *_confirm)
+{
+  I64 i,bpc,size,c,errs=0;
+  CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
+  U8 *files_find_mask=MStrPrint("%c:/*",Drv2Let(dv)),
+	*old_dir=StrNew(Fs->cur_dir),
+	*bits;
+  U32 *bits2;
+  Drv(drv_let);
+  "Scanning...\n";
+  size=(dv->size-(dv->data_area-dv->drv_offset))/dv->spc;
+  bpc=dv->spc<<BLK_SIZE_BITS;
+  bits=CAlloc((size+7)>>3);
+  bits2=CAlloc(size*4+BLK_SIZE);
+  BlkRead(dv,bits2,dv->fat1,(size*4+BLK_SIZE-1)>>BLK_SIZE_BITS);
+
+  c=dv->root_clus;
+  while (0<c<0x0FFFFFF8) {
+    if (c>size) {
+      PrintErr("Invalid Clus: RootDir Clus:%X\n",c);
+      errs++;
+      break;
+    }
+    if (LBts(bits,c)) {
+      PrintErr("Dbl Alloc: RootDir Clus:%X\n",c);
+      errs++;
+    }
+    if (!bits2[c]) {
+      PrintErr("UnAlloc: RootDir Clus:%X\n",c);
+      errs++;
+    } else
+      bits2[c]=0;
+    c=ClusNumNext(dv,c);
+  }
+
+  errs+=FAT32ChkDskLst(dv,FilesFind(files_find_mask,FUF_RECURSE),
+	bits,bits2,size,bpc);
+
+  bits2[1]=0; //See $LK,"FAT32Fmt",A="MN:FAT32Fmt"$()
+  for (i=1;i<size;i++)
+    if (bits2[i]) {
+      PrintWarn("Shouldn't Alloc Clus:%0X\n",i);
+      errs++;
+      if (ChkDskConfirm(_fix,_confirm))
+	FAT32FreeClus(dv,i);
+    }
+  Free(files_find_mask);
+  Free(bits);
+  Free(bits2);
+  Drv(Drv2Let(old_dv));
+  Cd(old_dir);
+  Free(old_dir);
+  return errs;
+}
+
+public I64 DskChk(U8 drv_let=0,Bool fix=FALSE,Bool confirm=TRUE)
+{//Check disk for allocation errors and, optionally, fix.
+//You probably want to reformat and reinstall.
+  I64 errs=0;
+  CDrv *dv=Let2Drv(drv_let);
+  switch (dv->fs_type) {
+    case FSt_REDSEA:
+      errs=RedSeaChkDsk(drv_let,&fix,&confirm);
+      break;
+    case FSt_FAT32:
+      errs=FAT32ChkDsk(drv_let,&fix,&confirm);
+      break;
+    default:
+      PrintErr("File System Not Supported\n");
+  }
+  if (errs) {
+    if (fix)
+      "It might be a little better.  ";
+    "Copy files to another partition or CD/DVD, "
+	  "reformat, and copy back.  "
+	  "Or, copy from a back-up.\n";
+  }
+  return errs;
+}
+
+U0 RedSeaDrvView(U8 drv_let=0)
+{
+  CDrv *dv=Let2Drv(drv_let);
+  I64 lohi,c1,i,x,y,l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1),
+	s=dv->size+dv->drv_offset-dv->data_area;
+  U8 *bitmap;
+  CDC *dc=DCAlias;
+
+  SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
+  WinMax;
+  WinBorder(ON);
+  DocCursor;
+  DocClear;
+  DCFill;
+  try {
+    i=((s+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS;
+    bitmap=MAlloc(i<<BLK_SIZE_BITS);
+    BlkRead(dv,bitmap,dv->fat1,i);
+    i=0;
+    for (y=0;y<GR_HEIGHT-3*FONT_HEIGHT;y++) {
+      if (ScanKey)
+	break;
+      for (x=0;x<GR_WIDTH-FONT_WIDTH<<1;x++) {
+	lohi=i*s;
+	c1=lohi/l;
+	if (Bt(bitmap,c1))
+	  dc->color=ROP_XOR+BLUE^TRANSPARENT;
+	else
+	  dc->color=ROP_XOR+WHITE^TRANSPARENT;
+	GrPlot(dc,x,y);
+	i++;
+      }
+    }
+    Free(bitmap);
+  } catch
+    DrvUnlock(dv);
+  GetChar;
+
+  SettingsPop;
+  DCFill;
+  DCDel(dc);
+}
+U0 FAT32DrvView(U8 drv_let=0)
+{
+  CDrv *dv=Let2Drv(drv_let);
+  I64 lohi,c1,i,x,y,l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1),
+	s=(dv->size+dv->spc-1)/dv->spc-(2+dv->data_area-dv->drv_offset);
+  U32 *bitmap;
+  CDC *dc=DCAlias;
+
+  SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
+  WinMax;
+  WinBorder(ON);
+  DocCursor;
+  DocClear;
+  DCFill;
+  try {
+    i=(s*4+BLK_SIZE-1)>>BLK_SIZE_BITS;
+    bitmap=MAlloc(i<<BLK_SIZE_BITS);
+    BlkRead(dv,bitmap,dv->fat1,i);
+    i=0;
+    for (y=0;y<GR_HEIGHT-3*FONT_HEIGHT;y++) {
+      if (ScanKey)
+	break;
+      for (x=0;x<GR_WIDTH-FONT_WIDTH<<1;x++) {
+	lohi=i*s;
+	c1=lohi/l;
+	if (bitmap[c1])
+	  dc->color=ROP_XOR+BLUE^TRANSPARENT;
+	else
+	  dc->color=ROP_XOR+WHITE^TRANSPARENT;
+	GrPlot(dc,x,y);
+	i++;
+      }
+    }
+    Free(bitmap);
+  } catch
+    DrvUnlock(dv);
+  GetChar;
+
+  SettingsPop;
+  DCFill;
+  DCDel(dc);
+}
+public U0 DrvView(U8 drv_let=0)
+{//Drive view. Graph the allocation map's fragmentation.
+  CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
+  Drv(drv_let);
+  switch (dv->fs_type) {
+    case FSt_REDSEA:
+      RedSeaDrvView(drv_let);
+      break;
+    case FSt_FAT32:
+      FAT32DrvView(drv_let);
+      break;
+    default:
+      PrintErr("File System Not Supported\n");
+  }
+  Drv(Drv2Let(old_dv));
+}
+
+public U0 DskView(U8 drv_let=0)
+{//Disk view. Pie chart of partition sizes.
+  I64 i,j,attr,
+	h=Fs->pix_width,
+	v=Fs->pix_height,
+	radius;
+  CDrv *dv;
+  CBlkDev *bd=Let2BlkDev(drv_let);
+  CDC *dc=DCAlias;
+  F64 sect_start,sect_end;
+
+  SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
+  DocCursor;
+  DocClear;
+  DCFill;
+  if (h<v)
+    radius=0.4*h;
+  else
+    radius=0.4*v;
+  dc->color=BLACK;
+  GrCircle(dc,h>>1,v>>1,radius);
+
+  j=1;
+  for (i=0;i<DRVS_NUM;i++) {
+    dv=&blkdev.drvs[i];
+    if (bd==dv->bd && dv->fs_type) {
+      sect_start=-(dv->drv_offset*2*ã/(bd->max_blk+1));
+      sect_end	=-((dv->drv_offset+dv->size)*2*ã/(bd->max_blk+1));
+      dc->color=BLACK;
+      GrLine(dc,h>>1,v>>1,
+	    h>>1+radius*Cos(sect_start),
+	    v>>1+radius*Sin(sect_start));
+      GrLine(dc,h>>1,v>>1,
+	    h>>1+radius*Cos(sect_end),
+	    v>>1+radius*Sin(sect_end));
+
+      attr=DrvTextAttrGet(Drv2Let(dv));
+      dc->color=attr&15;
+      GrPrint(dc,0,v-FONT_HEIGHT*j,"%C %-8Z",Drv2Let(dv),
+	    dv->fs_type,"ST_DRV_TYPES");
+      dc->color.c1=attr>>4;
+      dc->color|=ROPF_DITHER;
+      GrFloodFill(dc,
+	    h>>1+(radius-4)*Cos((sect_start+sect_end)/2),
+	    v>>1+(radius-4)*Sin((sect_start+sect_end)/2),FALSE);
+      j++;
+    }
+  }
+
+  GetChar(,FALSE);
+  SettingsPop;
+  DCFill;
+  DCDel(dc);
+}
+
+I64 RedSeaUnusedDrvSpace(U8 drv_let=0)
+{
+  CDrv *dv=Let2Drv(drv_let);
+  I64 res=0,i,l;
+  U8 *bitmap;
+  try {
+    l=dv->size+dv->drv_offset-dv->data_area;
+    i=((l+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS;
+    bitmap=MAlloc(i<<BLK_SIZE_BITS);
+    BlkRead(dv,bitmap,dv->fat1,i);
+    for (i=0;i<l;i++)
+      if (!Bt(bitmap,i))
+	res++;
+    Free(bitmap);
+  } catch
+    DrvUnlock(dv);
+  return res*BLK_SIZE*dv->spc;
+}
+I64 FAT32UnusedDrvSpace(U8 drv_let=0)
+{
+  CDrv *dv=Let2Drv(drv_let);
+  I64 res=0,i,l;
+  U32 *bitmap;
+  try {
+    l=(dv->size+dv->spc-1)/dv->spc-(2+dv->data_area-dv->drv_offset);
+    i=(l*4+BLK_SIZE-1)>>BLK_SIZE_BITS;
+    bitmap=MAlloc(i<<BLK_SIZE_BITS);
+    BlkRead(dv,bitmap,dv->fat1,i);
+    for (i=0;i<l;i++)
+      if (!bitmap[i])
+	res++;
+    Free(bitmap);
+  } catch
+    DrvUnlock(dv);
+  return res*BLK_SIZE*dv->spc;
+}
+public I64 UnusedDrvSpace(U8 drv_let=0)
+{//Returns unused size in bytes.
+  CDrv *dv=Let2Drv(drv_let),*old_dv=Fs->cur_dv;
+  U8 *old_dir=StrNew(Fs->cur_dir);
+  I64 res=0;
+  Drv(drv_let);
+  switch (dv->fs_type) {
+    case FSt_REDSEA:
+      res=RedSeaUnusedDrvSpace(drv_let);
+      break;
+    case FSt_FAT32:
+      res=FAT32UnusedDrvSpace(drv_let);
+      break;
+    default:
+      PrintErr("File System Not Supported\n");
+  }
+  Drv(Drv2Let(old_dv));
+  Cd(old_dir);
+  Free(old_dir);
+  return res;
+}

TempleOSCD/Adam/ABlkDev/DskPrt.HC

@@ -0,0 +1,167 @@
+#help_index "Install;File/Cmd Line (Typically);Cmd Line (Typically)"
+
+#define ROUND_DRV_TO	(63*255)
+#define DRV_HEADER	63
+
+class CPlannedDrv
+{
+  CPlannedDrv *next,*last;
+  I64 size;
+  Bool pri;
+};
+
+public I64 DskPrt(U8 drv_let=0,...)
+{/*Partition the disk containing partition drv_let.
+
+drv_let=0 means add new drive that is not already mounted.
+
+>DskPrt('C',0.5,0.25,0.25); //Make three.  50% C, 25% D, 25% E, round-up to blk.
+
+*/
+  CBlkDev *bd;
+  CPlannedDrv head,*tmppp;
+  CMasterBoot mbr;
+  Bool pri=TRUE;
+  I64 ext_base,drv_let2,pri_cnt=0,i,start_offset,offset,
+	total,remaining,cur_arg=0;
+  "This command does not play well\n"
+	"with other operating systems.\n"
+	"You really should use another\n"
+	"operating system's partitioner.\n"
+	"If you use this, it may, in fact,\n"
+	"make your hard drive impossible\n"
+	"to repartition with other operating\n"
+	"until you set block zero to zero\n"
+	"with $$LK,\"BootMHDZero\",\"MN:BootMHDZero\"$$()\n\n\n"
+	"Continue";
+  if (argc<=cur_arg && !YorN)
+    return 0;
+  '\n';
+
+  if (drv_let && !Let2BlkDev(drv_let,FALSE))
+    drv_let=0;
+  if (!drv_let && !(drv_let=Mount(TRUE)) ||
+	!(bd=Let2BlkDev(drv_let,FALSE)) || bd->type!=BDT_ATA)
+    return 0;
+
+  total=bd->max_blk+1;
+  QueInit(&head);
+  drv_let2=bd->first_drv_let;
+  remaining=FloorU64(bd->max_blk+1,ROUND_DRV_TO);
+  while (FloorU64(remaining,ROUND_DRV_TO)>=ROUND_DRV_TO) {
+    tmppp=MAlloc(sizeof(CPlannedDrv));
+    do {
+      "$$RED$$Partition %C$$FG$$\n",drv_let2;
+      tmppp->pri=FALSE;
+      if (pri) {
+	"Primary Partition";
+	if (argc>cur_arg || YorN) {
+	  pri_cnt++;
+	  tmppp->pri=TRUE;
+	  if (pri_cnt==3)
+	    pri=FALSE;
+	} else
+	  pri=FALSE;
+      }
+      "\nBlocks Remaining:%d (0x%X)\n",
+	    remaining-DRV_HEADER,remaining-DRV_HEADER;
+      if (argc>cur_arg)
+	tmppp->size=MinI64(CeilU64(MaxI64(remaining,DRV_HEADER),ROUND_DRV_TO),
+	      CeilU64(argv[cur_arg++](F64)*total,ROUND_DRV_TO));
+      else
+	tmppp->size=CeilU64(GetI64("Size in Blocks  :",
+	      remaining-DRV_HEADER)+DRV_HEADER,ROUND_DRV_TO);
+    } while (!(ROUND_DRV_TO<=tmppp->size<=FloorU64(remaining,ROUND_DRV_TO)));
+    QueIns(tmppp,head.last);
+    remaining-=tmppp->size;
+    drv_let2++;
+  }
+
+  "\n\n!!! Repartition Drive !!!\n\n";
+  tmppp=head.next;
+  drv_let2=bd->first_drv_let;
+  while (tmppp!=&head) {
+    "Drive %C:%08X ",drv_let2,tmppp->size;
+    if (tmppp->pri)
+      "Primary\n";
+    else
+      "Logical\n";
+    tmppp=tmppp->next;
+    drv_let2++;
+  }
+  if (!argc && !AreYouSure)
+    goto pd_done;
+
+  remaining=FloorU64(bd->max_blk+1,ROUND_DRV_TO)-ROUND_DRV_TO;
+  tmppp=head.next;
+  MemSet(&mbr,0,BLK_SIZE);
+  mbr.signature=0xAA55;
+  offset=0;
+  for (i=0;i<pri_cnt;i++) {
+    mbr.p[i].active=0x80;
+    mbr.p[i].start_head=0;
+    mbr.p[i].start_cyl=0x101;
+    mbr.p[i].type=1; //Will get set different.
+    mbr.p[i].end_head=0xFE;
+    mbr.p[i].end_cyl=0xFFFF;
+    mbr.p[i].offset=DRV_HEADER+offset;
+    mbr.p[i].size=tmppp->size-DRV_HEADER;
+    offset+=tmppp->size;
+    remaining-=tmppp->size;
+    tmppp=tmppp->next;
+  }
+  if (!i) i++;
+  if (tmppp!=&head) {
+    mbr.p[i].active=0x80;
+    mbr.p[i].start_head=0;
+    mbr.p[i].start_cyl=0x101;
+    mbr.p[i].type=0xF;
+    mbr.p[i].end_head=0xFE;
+    mbr.p[i].end_cyl=0xFFFF;
+    mbr.p[i].offset=offset;
+    mbr.p[i].size=remaining;
+    ext_base=offset;
+  }
+  ATAWriteBlks(bd,&mbr,0,1);
+
+  while (tmppp!=&head) {
+    start_offset=offset;
+    MemSet(&mbr,0,BLK_SIZE);
+    mbr.signature=0xAA55;
+
+    mbr.p[0].active=0x80;
+    mbr.p[0].start_head=1;
+    mbr.p[0].start_cyl=0x101;
+    mbr.p[0].type=1; //Will get set different.
+    mbr.p[0].end_head=0xFE;
+    mbr.p[0].end_cyl=0xFFFF;
+    mbr.p[0].offset=DRV_HEADER;
+    mbr.p[0].size=tmppp->size-DRV_HEADER;
+    offset+=tmppp->size;
+    tmppp=tmppp->next;
+    if (tmppp!=&head) {
+      mbr.p[1].active=0x80;
+      mbr.p[1].start_head=0;
+      mbr.p[1].start_cyl=0x101;
+      mbr.p[1].type=5;
+      mbr.p[1].end_head=0xFE;
+      mbr.p[1].end_cyl=0xFFFF;
+      mbr.p[1].offset=offset-ext_base;
+      mbr.p[1].size=tmppp->size;
+    }
+    ATAWriteBlks(bd,&mbr,start_offset,1);
+  }
+
+  bd->flags&=~(BDF_INITIALIZED | BDF_INIT_IN_PROGRESS);
+  BlkDevAdd(bd,,FALSE,TRUE);
+  for (i=bd->first_drv_let;i<drv_let2;i++)
+    Fmt(i,,FALSE);
+
+    pd_done:
+  while (head.next!=&head) {
+    tmppp=head.next;
+    QueRem(tmppp);
+    Free(tmppp);
+  }
+  return total;
+}

TempleOSCD/Adam/ABlkDev/FileMgr.HC

@@ -284,7 +284,7 @@ U0 FMMkDir(CDoc *doc)
       Cd(parent->full_name);
       if (DocForm(&fn)) {
 	Silent;
-	MkDir(fn.name);
+	DirMk(fn.name);
 	Silent(OFF);
       }
     }
@@ -293,7 +293,7 @@ U0 FMMkDir(CDoc *doc)
     Cd(tmpde->full_name);
     if (DocForm(&fn)) {
       Silent;
-      MkDir(fn.name);
+      DirMk(fn.name);
       Silent(OFF);
     }
   }
@@ -335,7 +335,7 @@ U0 FMChgDsk(CDoc *doc)
     while (tmpde->parent)
       tmpde=tmpde->parent;
     Silent;
-    ChgDsk(*tmpde->full_name);
+    DskChg(*tmpde->full_name);
     Silent(OFF);
   }
 }
@@ -596,7 +596,7 @@ public U8 *FileMgr(I64 mode=FM_NORMAL,CTask *mem_task=NULL)
   CDirEntry *head=NULL,*tmpde,*tmpde1,*tmpde2;
   I64 sc,ch,arg1,arg2,msg_code;
   CDoc *doc=NULL,*old_put_doc=DocPut,*old_display_doc=DocDisplay;
-  U8 *res=NULL,*st,*st2,*old_cur_dir=CurDir;
+  U8 *res=NULL,*st,*st2,*old_cur_dir=DirCur;
   CDocEntry *doc_ce=NULL,*doc_e;
   Bool okay;
 

TempleOSCD/Adam/ABlkDev/MakeABlkDev.HC

@@ -1,8 +1,8 @@
 Cd(__DIR__);;
 #include "ADskA"
 #include "ADskB"
-#include "PrtDsk"
+#include "DskPrt"
 #include "Mount"
-#include "ChkDsk"
+#include "DskChk"
 #include "FileMgr"
 Cd("..");;

TempleOSCD/Adam/ABlkDev/Mount.HC

@@ -120,9 +120,9 @@ U8 Mount2(U8 boot_drv_let,CDoc *_doc,Bool _caller_is_prtdsk)
 	if ((cnt=ExeDoc(doc)) && whole_drv) {
 	  if (_caller_is_prtdsk) {
 	    res=drv_let;
-	    PrtDsk(drv_let,1.0); //First mount whole drive.
+	    DskPrt(drv_let,1.0); //First mount whole drive.
 	  } else
-	    PrtDsk(drv_let);
+	    DskPrt(drv_let);
 	}
 	DocDel(doc);
       }
@@ -136,7 +136,7 @@ U8 Mount2(U8 boot_drv_let,CDoc *_doc,Bool _caller_is_prtdsk)
 }
 
 public U8 Mount(Bool caller_is_prtdsk=FALSE)
-{//Mount drives. Called from $LK,"PrtDsk(Mount)",A="FF:::/Adam/ABlkDev/PrtDsk.HC,Mount("$.
+{//Mount drives. Called from $LK,"DskPrt(Mount)",A="FF:::/Adam/ABlkDev/DskPrt.HC,Mount("$.
   return Mount2(0,NULL,caller_is_prtdsk);
 }
 
@@ -147,7 +147,7 @@ public U0 Unmount(U8 drv_let=0)
 
 public U8 MountFile(U8 *filename)
 {//Mount ISO.C file.
-  U8 *filename2=DftExt(filename,"ISO.C"),*filename3=FileNameAbs(filename2);
+  U8 *filename2=ExtDft(filename,"ISO.C"),*filename3=FileNameAbs(filename2);
   CDrv *dv=DrvMakeFreeSlot(DrvNextFreeLet('M')); //First $LK,"BDT_ISO_FILE_READ",A="MN:BDT_ISO_FILE_READ"$
   CBlkDev *bd=BlkDevNextFreeSlot(dv->drv_let,BDT_ISO_FILE_READ);
   bd->drv_offset=19<<2+(DVD_BLK_SIZE*2+DVD_BOOT_LOADER_SIZE)/BLK_SIZE;

TempleOSCD/Adam/AHash.HC

@@ -373,7 +373,7 @@ public U0 PopUpHelpIndex(U8 *idx,CTask *parent=NULL)
 #help_index "Hash/System"
 public U0 MapFileLoad(U8 *filename)
 {//Load map file so we have src line info.
-  U8 *st,*ptr,*name=DftExt(filename,"MAP.Z"),
+  U8 *st,*ptr,*name=ExtDft(filename,"MAP.Z"),
 	*absname=FileNameAbs(name);
   CDoc *doc=DocRead(name);
   CDocEntry *doc_e;

TempleOSCD/Adam/AutoComplete/ACFill.HC

@@ -11,7 +11,7 @@ public U8 *ACDDefGet(U8 *st,I64 def_num=1)
     if (f=FOpen(ACD_DEF_FILENAME,"r")) {
       buf=MAlloc(ACD_BLK_SIZE*2+1);
       buf[ACD_BLK_SIZE*2]=0; //terminate
-      FRBlks(f,buf,tmph->user_data0*ACD_BLK_SIZE/BLK_SIZE,
+      FBlkRead(f,buf,tmph->user_data0*ACD_BLK_SIZE/BLK_SIZE,
 	    ACD_BLK_SIZE*2/BLK_SIZE);
       FClose(f);
       in_ptr=buf;
@@ -55,7 +55,7 @@ public U8 *ACDDefsGet(U8 *st)
     if (f=FOpen(ACD_DEF_FILENAME,"r")) {
       buf=MAlloc(ACD_BLK_SIZE*2+1);
       buf[ACD_BLK_SIZE*2]=0; //terminate
-      FRBlks(f,buf,tmph->user_data0*ACD_BLK_SIZE/BLK_SIZE,
+      FBlkRead(f,buf,tmph->user_data0*ACD_BLK_SIZE/BLK_SIZE,
 	    ACD_BLK_SIZE*2/BLK_SIZE);
       FClose(f);
       in_ptr=buf;

TempleOSCD/Adam/AutoComplete/ACInit.HC

@@ -96,7 +96,7 @@ U0 ACMainFileLstTraverse(U8 *files_find_mask)
   CDirEntry *tmpde,*tmpde1;
   try {
     tmpde=tmpde1=FilesFind(files_find_mask,
-	  FUF_RECURSE|FUF_JUST_TXT|FUF_JUST_FILES|FUF_CLUSTER_ORDER);
+	  FUF_RECURSE|FUF_JUST_TXT|FUF_JUST_FILES|FUF_CLUS_ORDER);
     while (tmpde) {
       "%s\n",tmpde->full_name;
       buf=FileRead(tmpde->full_name);

TempleOSCD/Adam/DolDoc/DocCodeTools.HC

@@ -440,7 +440,7 @@ U0 EdCodeTools2(CDoc *doc,I64 tool_action,Bool beep=TRUE)
 	DocFlagsToggle(doc,DOCF_PLAIN_TEXT);
       DocWrite(doc);
       task=Spawn(&SrvCmdLine,NULL,"Srv",,Fs);
-      st2=CurDir;
+      st2=DirCur;
       st=MStrPrint("Cd(\"%s\");",st2);
       tmpc=TaskExe(task,Fs,st,1<<JOBf_WAKE_MASTER|1<<JOBf_FOCUS_MASTER);
       Free(st2);

TempleOSCD/Adam/DolDoc/DocPopUp.HC

@@ -28,7 +28,7 @@ public U8 *PopUpPickFile(U8 *dir=NULL)
   if (dir)
     st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_FILE,Fs->parent_task);",dir);
   else {
-    st2=CurDir;
+    st2=DirCur;
     st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_FILE,Fs->parent_task);",st2);
     Free(st2);
   }
@@ -43,7 +43,7 @@ public U8 *PopUpPickDir(U8 *dir=NULL)
   if (dir)
     st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_DIR,Fs->parent_task);",dir);
   else {
-    st2=CurDir;
+    st2=DirCur;
     st=MStrPrint("Cd(\"%Q\");FileMgr(FM_PICK_DIR,Fs->parent_task);",st2);
     Free(st2);
   }
@@ -264,7 +264,7 @@ public I64 AdamFile(U8 *filename,Bool warn_ext=TRUE)
 {//Make adam_task execute file.
   Bool okay=TRUE;
   U8 *name=FileNameAbs(filename),
-	*name2=DftExt(name,"HC.Z");
+	*name2=ExtDft(name,"HC.Z");
   I64 res=0;
   if (warn_ext &&
 	!FilesFindMatch(name2,FILEMASK_JIT) &&
@@ -282,7 +282,7 @@ public I64 PopUpFile(U8 *filename,Bool warn_ext=TRUE,
 {//$LK,"ExeFile2",A="MN:ExeFile2"$() in $LK,"PopUp",A="MN:PopUp"$ task. Cont as User.
   Bool okay=TRUE;
   U8 *st,*name=FileNameAbs(filename),
-	*name2=DftExt(name,"HC.Z");
+	*name2=ExtDft(name,"HC.Z");
   I64 res=0;
   if (warn_ext &&
 	!FilesFindMatch(name2,FILEMASK_JIT) &&
@@ -304,7 +304,7 @@ public I64 PopUpFile(U8 *filename,Bool warn_ext=TRUE,
 public I64 PopUpRunFile(U8 *filename,I64 ccf_flags=0,...)
 {//$LK,"ExeFile",A="MN:ExeFile"$() with args using $LK,"LastFun",A="MN:LastFun"$() in $LK,"PopUp",A="MN:PopUp"$ task.
   U8 *st,*name=FileNameAbs(filename),
-	*name2=DftExt(name,"HC.Z");
+	*name2=ExtDft(name,"HC.Z");
   I64 res=0;
   st=MStrPrint(
 	"\"$$$$WW+H,1$$$$\";ExeFile2(\"%s\",0x%X);LastFun(0x%X,0x%X);",

TempleOSCD/Adam/Gr/GrDC.HC

@@ -379,7 +379,7 @@ public CDC *DCLoad(U8 *src,I64 *_size=NULL,CTask *task=NULL)
 public I64 GRWrite(U8 *filename,CDC *dc,I64 dcsf_flags=DCSF_COMPRESSED)
 {//TempleOS GR File.
   I64	size;
-  U8	*st=DftExt(filename,"GR.Z"),
+  U8	*st=ExtDft(filename,"GR.Z"),
 	*src=DCSave(dc,&size,dcsf_flags);
   FileWrite(st,src,size);
   Free(st);
@@ -390,7 +390,7 @@ public I64 GRWrite(U8 *filename,CDC *dc,I64 dcsf_flags=DCSF_COMPRESSED)
 public CDC *GRRead(U8 *filename,CTask *task=NULL)
 {//TempleOS GR File.
   CDC	*dc=NULL;
-  U8	*st=DftExt(filename,"GR.Z"),
+  U8	*st=ExtDft(filename,"GR.Z"),
 	*src=FileRead(st);
   if (src)
     dc=DCLoad(src,,task);

TempleOSCD/Adam/Host.HC

@@ -59,8 +59,8 @@ Place the CDDVD %s in the drive.
 ",iso_filename;
     }
     if (PressAKey!=CH_SHIFT_ESC) {
-      ">$FG,2$ChgDsk('T');$FG$\n\n";
-      ChgDsk('T');
+      ">$FG,2$DskChg('T');$FG$\n\n";
+      DskChg('T');
       res=TRUE;
     }
   } catch

TempleOSCD/Adam/Opt/Boot/BootHDIns.HC

@@ -35,19 +35,19 @@ public U0 BootHDIns(U8 drv_let=0)
 	else {
 	  Free(de.full_name);
 	  "Modifying partition boot record.\n";
-	  RBlks(dv,&br,dv->drv_offset,1);
+	  BlkRead(dv,&br,dv->drv_offset,1);
 	  br.jump_and_nop[0]=OC_JMP_REL8;
 	  br.jump_and_nop[1]=offset(CFAT32Boot.code)-2;
 #assert offset(CFAT32Boot.code)>=offset(CRedSeaBoot.code)
 	  br.jump_and_nop[2]=OC_NOP;
 	  *BHD_BLK_CNT(U16 *)=(de.size+BLK_SIZE-1)>>BLK_SIZE_BITS;
-	  *BHD_DAP_BLK(I64 *)=Cluster2Blk(dv,de.cluster);
+	  *BHD_DAP_BLK(I64 *)=Clus2Blk(dv,de.clus);
 	  for (i=0;i<BHD_END-BHD_CODE;i++)
 	    br.code[i]=BHD_CODE(U8 *)[i];
 #assert sizeof(CFAT32Boot.code)>=BHD_END-BHD_CODE
 	  for (;i<sizeof(CFAT32Boot.code);i++)
 	    br.code[i]=0;
-	  WBlks(dv,&br,dv->drv_offset,1);
+	  BlkWrite(dv,&br,dv->drv_offset,1);
 	}
 	break;
       default:

TempleOSCD/Adam/Opt/Boot/BootMHDIns.HC

@@ -29,7 +29,7 @@ public U0 BootMHDOldRead(U8 src_drv,U8 dst_drv)
     BlkDevUnlock(bd);
 
     Drv(dst_drv);
-    MkDir(BOOT_DIR);
+    DirMk(BOOT_DIR);
     FileWrite(BOOT_DIR_OLDMBR_BIN_C,&mbr,BLK_SIZE);
   }
 }
@@ -103,7 +103,7 @@ public Bool BootMHDIns(U8 drv_let,U8 *drv_lst=NULL)
       j=0;
       if (FileFind(BOOT_DIR_OLDMBR_BIN_C,&de,FUF_JUST_FILES)) {
 	Free(de.full_name);
-	*_q++=Cluster2Blk(dv,de.cluster);
+	*_q++=Clus2Blk(dv,de.clus);
 	CatPrint(menu_ptr,"0. Old Boot Record\n\r");
 	j++;
       }
@@ -127,7 +127,7 @@ public Bool BootMHDIns(U8 drv_let,U8 *drv_lst=NULL)
       else {
 	Free(de.full_name);
 	*BMHD_BLK_CNT(U16 *)=(size+BLK_SIZE-1)>>BLK_SIZE_BITS;
-	*BMHD_DAP_BLK(I64 *)=Cluster2Blk(dv,de.cluster);
+	*BMHD_DAP_BLK(I64 *)=Clus2Blk(dv,de.clus);
 //Bypass partition bounds-checking
 	BlkDevLock(bd);
 	ATAReadBlks(bd,&mbr,0,1);

TempleOSCD/Adam/Opt/Boot/DskISO9660.HC

@@ -124,8 +124,8 @@ I64 DVDFileCreate2(CFile *out_file,CDirEntry *tmpde,CISO1DirEntry *tmpi,
 	  MemSet(buf,0,DVD_BLK_SIZE);
 	}
 	if (write) {
-	  FRBlks(in_file,buf,i<<2,n);
-	  FWBlks(out_file,buf,*_cur_blk<<2,n);
+	  FBlkRead(in_file,buf,i<<2,n);
+	  FBlkWrite(out_file,buf,*_cur_blk<<2,n);
 	}
 	*_cur_blk+=1;
       }
@@ -181,7 +181,7 @@ I64 DVDFileCreate2(CFile *out_file,CDirEntry *tmpde,CISO1DirEntry *tmpi,
   if (write)
     "%X:%s\n",*_cur_blk,tmpde->full_name;
   if (write)
-    FWBlks(out_file,dir_blk_buf,*_cur_blk<<2,n<<2);
+    FBlkWrite(out_file,dir_blk_buf,*_cur_blk<<2,n<<2);
   *_cur_blk+=n;
 
   tmpi2->len=sizeof(CISO1DirEntry)-1;
@@ -212,7 +212,7 @@ I64 DVDFileCreate2(CFile *out_file,CDirEntry *tmpde,CISO1DirEntry *tmpi,
   if (write)
     "%X:%s\n",*_cur_blk,tmpde->full_name;
   if (write)
-    FWBlks(out_file,dir_blk_buf2,*_cur_blk<<2,n<<2);
+    FBlkWrite(out_file,dir_blk_buf2,*_cur_blk<<2,n<<2);
   *_cur_blk+=n;
 
   Free(dir_blk_buf);
@@ -328,7 +328,7 @@ public I64 ISO9660ISO(U8 *_filename=NULL,U8 *src_files_find_mask,
 
   if (!_filename)
     _filename=blkdev.dft_iso_filename;
-  filename=DftExt(_filename,"ISO");
+  filename=ExtDft(_filename,"ISO");
 
   if (_stage2_filename)
     stage2_filename=FileNameAbs(_stage2_filename);
@@ -367,7 +367,7 @@ public I64 ISO9660ISO(U8 *_filename=NULL,U8 *src_files_find_mask,
     goto cf_done;
 
   while (cur_blk<20<<2>>2)
-    FWBlks(out_file,zero_buf,cur_blk++<<2,4);
+    FBlkWrite(out_file,zero_buf,cur_blk++<<2,4);
 
   iso_pri->type=ISO1T_PRI_VOL_DESC;
   StrCpy(iso_pri->id,"CD001");
@@ -407,7 +407,7 @@ public I64 ISO9660ISO(U8 *_filename=NULL,U8 *src_files_find_mask,
     et->sect_cnt=4;  //5 seems like the limit, 4 is safer
     et->load_rba=cur_blk+1;
     "%X: Pre Boot Blk\n",cur_blk;
-    FWBlks(out_file,et,cur_blk++<<2,4);
+    FBlkWrite(out_file,et,cur_blk++<<2,4);
     "%X: Boot Stage 1\n",cur_blk;
     cur_blk+=DVD_BOOT_LOADER_SIZE/DVD_BLK_SIZE;
   }
@@ -434,10 +434,10 @@ public I64 ISO9660ISO(U8 *_filename=NULL,U8 *src_files_find_mask,
   for (i=1;i<=max_depth;i++)
     DVDFillPathTable(headdir,&itabbuf,&itabbuf2,1,FALSE,&first_free,1,i);
   "%X: Path Table 0\n",cur_blk;
-  FWBlks(out_file,tabbuf,cur_blk<<2,tabsize<<2);
+  FBlkWrite(out_file,tabbuf,cur_blk<<2,tabsize<<2);
   cur_blk+=tabsize;
   "%X: Path Table 1\n",cur_blk;
-  FWBlks(out_file,tabbuf2,cur_blk<<2,tabsize2<<2);
+  FBlkWrite(out_file,tabbuf2,cur_blk<<2,tabsize2<<2);
   cur_blk+=tabsize2;
 
   MemSet(tabbuf,0,tabsize*DVD_BLK_SIZE);
@@ -458,35 +458,35 @@ public I64 ISO9660ISO(U8 *_filename=NULL,U8 *src_files_find_mask,
   for (i=1;i<=max_depth;i++)
     DVDFillPathTable(headdir,&itabbuf,&itabbuf2,1,TRUE,&first_free,1,i);
   "%X: Path Table 2\n",cur_blk;
-  FWBlks(out_file,tabbuf,cur_blk<<2,tabsize<<2);
+  FBlkWrite(out_file,tabbuf,cur_blk<<2,tabsize<<2);
   cur_blk+=tabsize;
   "%X: Path Table 3\n",cur_blk;
-  FWBlks(out_file,tabbuf2,cur_blk<<2,tabsize2<<2);
+  FBlkWrite(out_file,tabbuf2,cur_blk<<2,tabsize2<<2);
   cur_blk+=tabsize2;
 
   DirTreeDel2(headdir);
   FillU32Palindrome(&iso_pri->vol_space_size,cur_blk);
   FillU32Palindrome(&iso_sup->vol_space_size,cur_blk);
-  FWBlks(out_file,iso_pri,16<<2,4);
+  FBlkWrite(out_file,iso_pri,16<<2,4);
 
   iso_term->type=ISO1T_TERMINATOR;
   StrCpy(iso_term->id,"CD001");
   iso_term->version=1;
   if (stage2_filename) {
-    FWBlks(out_file,iso_boot,17<<2,4);
-    FWBlks(out_file,iso_sup,18<<2,4);
-    FWBlks(out_file,iso_term,19<<2,4);
+    FBlkWrite(out_file,iso_boot,17<<2,4);
+    FBlkWrite(out_file,iso_sup,18<<2,4);
+    FBlkWrite(out_file,iso_term,19<<2,4);
     stage2_size=(Size(stage2_filename,"+s")+DVD_BLK_SIZE-1)/DVD_BLK_SIZE;
     MemCpy(stage1_buf,BDVD_START,BDVD_END-BDVD_START);
     *(BDVD_BLK_CNT-BDVD_START+stage1_buf)(U16 *)=stage2_size;
     *(BDVD_BLK_LO -BDVD_START+stage1_buf)(U32 *)=stage2_blk;
     "$$RED$$!!! Boot Stage 2 !!! %X-%X$$FG$$\n",
 	  stage2_blk,stage2_blk+stage2_size-1;
-    FWBlks(out_file,stage1_buf,
+    FBlkWrite(out_file,stage1_buf,
 	  20<<2+1<<2,DVD_BOOT_LOADER_SIZE/BLK_SIZE);
   } else {
-    FWBlks(out_file,iso_sup,17<<2,4);
-    FWBlks(out_file,iso_term,18<<2,4);
+    FBlkWrite(out_file,iso_sup,17<<2,4);
+    FBlkWrite(out_file,iso_term,18<<2,4);
   }
 
   cf_done:

TempleOSCD/Adam/Opt/Boot/DskISORedSea.HC

@@ -32,13 +32,13 @@ U0 RedSeaISO9660Stage1(U8 *iso_filename,U8 *stage2_filename)
   U8	*stage1_buf=CAlloc(DVD_BOOT_LOADER_SIZE);
   if (FileFind(stage2_filename,&de) && (out_file=FOpen(iso_filename,"wc+"))) {
     MemCpy(stage1_buf,BDVD_START,BDVD_END-BDVD_START);
-    *(BDVD_BLK_LO	-BDVD_START+stage1_buf)(U32 *)=de.cluster>>2;
+    *(BDVD_BLK_LO	-BDVD_START+stage1_buf)(U32 *)=de.clus>>2;
     *(BDVD_BLK_CNT	-BDVD_START+stage1_buf)(U16 *)=
 	  (de.size+DVD_BLK_SIZE-1)>>(BLK_SIZE_BITS+2);
-    *(BDVD_SHIFT_BLKS	-BDVD_START+stage1_buf)(U16 *)=de.cluster&3;
-    if (de.cluster&3)
+    *(BDVD_SHIFT_BLKS	-BDVD_START+stage1_buf)(U16 *)=de.clus&3;
+    if (de.clus&3)
       *(BDVD_BLK_CNT	-BDVD_START+stage1_buf)(U16 *)+=1;
-    FWBlks(out_file,stage1_buf,
+    FBlkWrite(out_file,stage1_buf,
 	  20<<2+1<<2,DVD_BOOT_LOADER_SIZE/BLK_SIZE);
     FClose(out_file);
   }
@@ -61,7 +61,7 @@ U0 RedSeaISO9660(U8 *iso_filename,U8 drv_let)
   if (out_file=FOpen(iso_filename,"wc+")) {
     iso_size=FSize(out_file)/DVD_BLK_SIZE;
     for (i=0;i<dv->bd->drv_offset;i+=4)
-      FWBlks(out_file,zero_buf,i,4);
+      FBlkWrite(out_file,zero_buf,i,4);
 
     iso_pri->type=ISO1T_PRI_VOL_DESC;
     StrCpy(iso_pri->id,"CD001");
@@ -70,7 +70,7 @@ U0 RedSeaISO9660(U8 *iso_filename,U8 drv_let)
     FillU16Palindrome(&iso_pri->vol_seq_num,1);
     FillU16Palindrome(&iso_pri->log_block_size,DVD_BLK_SIZE);
     FillU32Palindrome(&iso_pri->vol_space_size,iso_size);
-    FillU32Palindrome(&iso_pri->root_dir_record,dv->root_cluster);
+    FillU32Palindrome(&iso_pri->root_dir_record,dv->root_clus);
     iso_pri->file_structure_version=1;
     StrCpy(iso_pri->publisher_id,"TempleOS RedSea");
 
@@ -82,17 +82,17 @@ U0 RedSeaISO9660(U8 *iso_filename,U8 drv_let)
     iso_boot->version=1;
     StrCpy(iso_boot(U8 *)+7,"EL TORITO SPECIFICATION");
 
-    FWBlks(out_file,iso_pri,16<<2,4);
+    FBlkWrite(out_file,iso_pri,16<<2,4);
     iso_term->type=ISO1T_TERMINATOR;
     StrCpy(iso_term->id,"CD001");
     iso_term->version=1;
 
     d=iso_boot(U8 *)+0x47;
     *d=20<<2>>2;
-    FWBlks(out_file,iso_boot,17<<2,4);
+    FBlkWrite(out_file,iso_boot,17<<2,4);
 
-    FWBlks(out_file,iso_sup,18<<2,4);
-    FWBlks(out_file,iso_term,19<<2,4);
+    FBlkWrite(out_file,iso_sup,18<<2,4);
+    FBlkWrite(out_file,iso_term,19<<2,4);
 
     et->w[0]=1;
     StrCpy(&et->w[2],"TempleOS");
@@ -105,7 +105,7 @@ U0 RedSeaISO9660(U8 *iso_filename,U8 drv_let)
     et->media_type=0;//0=no emu 2=1.44meg 4=hard drive
     et->sect_cnt=4;  //5 seems like the limit, 4 is safer
     et->load_rba=20<<2>>2+1;
-    FWBlks(out_file,et,20<<2,4);
+    FBlkWrite(out_file,et,20<<2,4);
     FClose(out_file);
   }
   Free(zero_buf);
@@ -147,7 +147,7 @@ public I64 RedSeaISO(U8 *_iso_filename=NULL,U8 *_src_dir,
   else {
     if (!_iso_filename)
       _iso_filename=blkdev.dft_iso_c_filename;
-    iso_filename=ChgExt(_iso_filename,"ISO.C");
+    iso_filename=ExtChg(_iso_filename,"ISO.C");
     src_dir=DirNameAbs(_src_dir);
     if (_stage2_filename) {
       stage2_filename=FileNameAbs(_stage2_filename);

TempleOSCD/Adam/Opt/Utils/LineRep.HC

@@ -63,7 +63,7 @@ I64 SizeRep1(CDirEntry *tmpde,I64 *_fuf_flags)
     else if ((i=tmpde->size) && Bt(_fuf_flags,FUf_EXPAND) &&
 	  FileAttr(tmpde->name)&RS_ATTR_COMPRESSED) {
       dv=Let2Drv(*tmpde->full_name);
-      RBlks(dv,buf,Cluster2Blk(dv,tmpde->cluster),1);
+      BlkRead(dv,buf,Clus2Blk(dv,tmpde->clus),1);
       i=(&buf)(CArcCompress *)->expanded_size;
     }
     tmpde->user_data=i;

TempleOSCD/Adam/Opt/Utils/MemRep.HC

@@ -115,7 +115,7 @@ Bool MemRepTask(CTask *task,Bool override_validate=FALSE)
 
   "HashTable\t:%010X\n",HashTableSize2(task->hash_table);
   "FPU\t\t:%010X\n",MSize2(task->fpu_mmx);
-  "CurDir\t:%010X\n",MSize2(task->cur_dir);
+  "DirCur\t:%010X\n",MSize2(task->cur_dir);
 
   if (pdoc=DocPut(task))
     "PutDoc\t:%010X\n",DocSize(pdoc);

TempleOSCD/Adam/Opt/Utils/StrUtils.HC

@@ -14,9 +14,9 @@ public I64 Sort(U8 *_in_name,U8 *_out_name=NULL,
   I64 i,j,cnt=0,res;
 
   if (!_in_name) return 0;
-  in_name=DftExt(_in_name,"DD.Z");
+  in_name=ExtDft(_in_name,"DD.Z");
   if (_out_name)
-    out_name=DftExt(_out_name,"DD.Z");
+    out_name=ExtDft(_out_name,"DD.Z");
   else
     out_name=StrNew(in_name);
 

TempleOSCD/Adam/Opt/Utils/ToTXT.HC

@@ -112,11 +112,11 @@ public U0 ToTXT(U8 *_in_name,U8 *_out_name=NULL,I64 width=70)
   SettingsPush; //See $LK,"SettingsPush",A="MN:SettingsPush"$
   WinHorz(0,width-1); //Sets doc width for word wrap.
 
-  in_name=DftExt(_in_name,"DD.Z");
+  in_name=ExtDft(_in_name,"DD.Z");
   if (_out_name)
-    out_name=DftExt(_out_name,"TXT");
+    out_name=ExtDft(_out_name,"TXT");
   else
-    out_name=ChgExt(_in_name,"TXT");
+    out_name=ExtChg(_in_name,"TXT");
 
   doc_in=DocRead(in_name);
   doc_out=Doc2TXT(doc_in);

TempleOSCD/Adam/TaskSettings.HC

@@ -10,7 +10,7 @@ public CTaskSettings *SettingsPush(CTask *task=NULL,I64 flags=0)
   if (!task) task=Fs;
   if (!TaskValidate(task)) return NULL;
   tmpse=CAlloc(sizeof(CTaskSettings),task);
-  tmpse->cur_dir=CurDir(task,task);
+  tmpse->cur_dir=DirCur(task,task);
   tmpse->draw_it=task->draw_it;
   GrPaletteGet(tmpse->palette);
   tmpse->task_end_cb=task->task_end_cb;