#help_index "File/Program Routines/Utils"

I64 CDirTreeFlattenSize(CDirEntry *tempm)
{
  I64 result=0;
  while (tempm) {
    result+=CDIR_SIZE+1;
    if (tempm->attr & _ATTR_DIR)
      result+=CDirTreeFlattenSize(tempm->sub);
    tempm=tempm->next;
  }
  return result+1;
}

I64 CDirTreeFlattenFill(CDirEntry *tempm,U8 *dst)
{
  I64 result=0,i;
  while (tempm) {
    *dst++=1;
    result++;
    i=CDIR_SIZE;
    MemCpy(dst,&tempm->start,i);
    dst+=i;
    result+=i;
    if (tempm->attr & _ATTR_DIR) {
      i=CDirTreeFlattenFill(tempm->sub,dst);
      dst+=i;
      result+=i;
    }
    tempm=tempm->next;
  }
  *dst=0;
  return result+1;
}

public U8 *CDirTreeFlatten(CDirEntry *tempm,I64 *_size=NULL)
{
  I64 size=CDirTreeFlattenSize(tempm);
  U8 *buf=MAlloc(size);
  CDirTreeFlattenFill(tempm,buf);
  if (_size) *_size=size;
  return buf;
}

U8 *CDirTreeDoUnflatten(U8 *src,CDirEntry **tempm)
{
  I64 i;
  CDirEntry *tempm1;
  if (*src++) {
    tempm1=CAlloc(sizeof(CDirEntry));
    *tempm=tempm1;
    i=CDIR_SIZE;
    MemCpy(&tempm1->start,src,i);
    src+=i;
    if (tempm1->attr & _ATTR_DIR)
      src=CDirTreeDoUnflatten(src,&tempm1->sub);
    src=CDirTreeDoUnflatten(src,&tempm1->next);
  } else
    *tempm=NULL;
  return src;
}

public CDirEntry *CDirTreeUnflatten(U8 *src)
{
  CDirEntry *tempm=NULL;
  CDirTreeDoUnflatten(src,&tempm);
  return tempm;
}

#help_index "Install;File/Install Related"
#help_file "::/SparrowOS/Doc/Install"

#define ROUND_PRT_TO	(63*255)
#define PRT_HEADER	63

class CPlannedPrt
{
  CPlannedPrt *next,*last;
  I64 size;
  Bool pri;
};

//This is available to assist in writing scripts.
I64 prt_dsk_dsk_size;

public U0 PrtDsk(U8 drv_let=0)
//Partition Disk containing partition drv_let.
//or drv_let=0 means add new drv that is not already mounted.
{
  CBlkDev *bdev;
  CPlannedPrt root,*temppp;
  CMasterBoot mbr;
  Bool pri=TRUE;
  I64 ext_base,num_prt,pri_cnt=0,
     i,start_offset,offset,remaining;
"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,\"MasterBootZero\",\"MN:MasterBootZero\"$$()\n\n\n"
"Continue";
  if (!YorN) return;

  if (drv_let)
    try
      Drv2BlkDev(drv_let);
    catch {
      drv_let=0;
      Fs->catch_except=TRUE;
    }

  if (!drv_let) {
    Mount(TRUE);
    return;
  }

  bdev=Drv2BlkDev(drv_let);
  if (!bdev || bdev->type!=BDT_ATA)
    return;

  prt_dsk_dsk_size=bdev->max_blk+1;

  QueInit(&root);

  num_prt=bdev->drv_let_base;
  remaining=FloorU64(bdev->max_blk+1,ROUND_PRT_TO);
  while (FloorU64(remaining,ROUND_PRT_TO)>=ROUND_PRT_TO) {
    temppp=MAlloc(sizeof(CPlannedPrt));
    do {
      "$$FG,RED$$Partition %C$$FG$$\n",num_prt;
      temppp->pri=FALSE;
      if (pri) {
	"Primary Partition";
	if (YorN) {
	  pri_cnt++;
	  temppp->pri=TRUE;
	  if (pri_cnt==3)
	    pri=FALSE;
	} else
	  pri=FALSE;
      }
      "Blocks Remaining:%d (0x%X)\n",
	remaining-PRT_HEADER,remaining-PRT_HEADER;
      temppp->size=CeilU64(PmtI64("Size in Blocks  :",
	remaining-PRT_HEADER)+PRT_HEADER,ROUND_PRT_TO);
    } while (!(ROUND_PRT_TO<=temppp->size<=FloorU64(remaining,ROUND_PRT_TO)));
    QueIns(temppp,root.last);
    remaining-=temppp->size;
    num_prt++;
  }

  "\n\n!!! Repartition Drive !!!\n\n";
  temppp=root.next;
  num_prt=bdev->drv_let_base;
  while (temppp!=&root) {
    "Drive %C:%08X %s\n",num_prt,temppp->size,
      temppp->pri ? "Primary":"Logical";
    temppp=temppp->next;
    num_prt++;
  }
  if (!AreYouSure)
    goto pd_done;

  remaining=FloorU64(bdev->max_blk+1,ROUND_PRT_TO)-ROUND_PRT_TO;
  temppp=root.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 to MBR_PT_NATIVE
    mbr.p[i].end_head=0xFE;
    mbr.p[i].end_cyl=0xFFFF;
    mbr.p[i].offset=PRT_HEADER+offset;
    mbr.p[i].size=temppp->size-PRT_HEADER;
    offset+=temppp->size;
    remaining-=temppp->size;
    temppp=temppp->next;
  }
  if (!i) i++;
  if (temppp!=&root) {
    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(bdev,&mbr,0,1);

  while (temppp!=&root) {
    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 to MBR_PT_NATIVE
    mbr.p[0].end_head=0xFE;
    mbr.p[0].end_cyl=0xFFFF;
    mbr.p[0].offset=PRT_HEADER;
    mbr.p[0].size=temppp->size-PRT_HEADER;
    offset+=temppp->size;
    temppp=temppp->next;
    if (temppp!=&root) {
      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=temppp->size;
    }
    ATAWriteBlks(bdev,&mbr,start_offset,1);
  }

  bdev->flags&=~(BDF_INITIALIZED | BDF_INIT_IN_PROGRESS);
  BlkDevAdd(bdev,FALSE);
  for (i=bdev->drv_let_base;i<num_prt;i++)
    Fmt(i,TRUE,FALSE);

pd_done:
  while (root.next!=&root) {
    temppp=root.next;
    QueRem(temppp);
    Free(temppp);
  }
}


#help_index "Info;File/Cmd Line (Typically);Cmd Line (Typically)"

U0 NativeFSDrvView(U8 drv_let=0)
{
  CPrt *p=Drv2Prt(drv_let);
  I64 lohi,c1,i,x,y,l,s;
  U8 *bitmap;
  CDC *dc=DCAlias;

  l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1),
  s=(p->size+p->spc-1)/p->spc;
 

  SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
  WinMax;
  DocCursor;
  DocClear;
  DCFill;
  try {
    i=((s+7)>>3+BLK_SIZE-1)>>BLK_SIZE_BITS;
    bitmap=MAlloc(i<<BLK_SIZE_BITS);
    RBlks(p,bitmap,p->map1,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^COLOR_TRANSPARENT;
	else
	  dc->color=ROP_XOR+WHITE^COLOR_TRANSPARENT;
	GrPlot(dc,x,y);
	i++;
      }
    }
    Free(bitmap);
  } catch
    PrtUnlock(p);
  GetChar;
 
  SettingsPop;
  DCFill;
  DCDel(dc);
}

U0 FAT32DrvView(U8 drv_let=0)
{
  CPrt *p=Drv2Prt(drv_let);
  I64 lohi,c1,i,x,y,l,s;
  U32 *bitmap;
  CDC *dc=DCAlias;
  l=(GR_HEIGHT-3*FONT_HEIGHT)*(GR_WIDTH-FONT_WIDTH<<1),
  s=(p->size+p->spc-1)/p->spc;
 

  SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
  WinMax;
  DocCursor;
  DocClear;
  DCFill;
  try {
    i=(s*4+BLK_SIZE-1)>>BLK_SIZE_BITS;
    bitmap=MAlloc(i<<BLK_SIZE_BITS);
    RBlks(p,bitmap,p->map1,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^COLOR_TRANSPARENT;
	else
	  dc->color=ROP_XOR+WHITE^COLOR_TRANSPARENT;
	GrPlot(dc,x,y);
	i++;
      }
    }
    Free(bitmap);
  } catch
    PrtUnlock(p);
  GetChar;
 
  SettingsPop;
  DCFill;
  DCDel(dc);
}

public U0 DrvView(U8 drv_let=0)
{
  CPrt *p=Drv2Prt(drv_let),*p_old=Fs->cur_prt;
  Drv(drv_let);
  switch (p->type) {
    case PT_NATIVE:
      NativeFSDrvView(drv_let);
      break;
    case PT_FAT32:
      FAT32DrvView(drv_let);
      break;
    default:
      PutDefineErr("ST_UNSUPPORTED_FILE_SYSTEM");
  }
  Drv(Prt2Drv(p_old));
}

public U0 DskView(U8 drv_let=0)
{
  I64 i,j,
    h=Fs->win_pixel_width,
    v=Fs->win_pixel_height,
    radius;
  CPrt *p;
  CBlkDev *bdev=Drv2BlkDevFwded(drv_let);
  CDC *dc=DCAlias;
  F64 sect_start,sect_end;

  SettingsPush; //See $LK,"SettingsPush","MN:SettingsPush"$
  DocCursor;
  DocClear;
  DCFill;
  if (h<v)
    radius=0.4*h;
  else
    radius=0.4*v;
  dc->color=ROP_EQU+BLACK;
  GrCircle(dc,h>>1,v>>1,radius);

  j=1;
  for (i=0;i<NUM_PRTS;i++) {
    p=&sys_prts[i];
    if (bdev==p->bdev && p->type) {
      sect_start=-(p->offset*2*ã/(bdev->max_blk+1));
      sect_end	=-((p->offset+p->size)*2*ã/(bdev->max_blk+1));
      dc->color=ROP_EQU+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));

      dc->color=ROP_EQU+j;
      GrPrintF(dc,0,v-FONT_HEIGHT*j,"%C %-8Z",Prt2Drv(p),
	p->type.u16[0],"ST_PRT_TYPES");
      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(NULL,FALSE);
  SettingsPop;
  DCFill;
  DCDel(dc);
}

#help_index "Info;File/Cmd Line (Typically);Cmd Line (Typically);File/Install Related;Install"
public U0 BlkDevRep()
{
  I64 i;
  for (i=0;i<num_blkdevs;i++)
    ClassRep("CBlkDev",&sys_blkdevs[i]);
}

#help_index "Install;File/Install Related"
#define SC_BLK_CNT	2048
public I64 NonNativeScan(I64 drv_let,U32 signature)
{
// See $LK,"::/SparrowOS/Doc/TSZ.TXT.Z","FI:::/SparrowOS/Doc/TSZ.TXT.Z"$
  U8 *buf=CAlloc(BLK_SIZE*SC_BLK_CNT),*b;
  U32 *d;
  CBlkDev *bdev=Drv2BlkDev(drv_let);
  CPrt *p=Drv2Prt(drv_let);
  I64 *qq,blk=p->offset,result=0,start=0,i,j,n,to_go,size,
      contiguous=0,new_drv_let;
  Bool good,proceed=FALSE;
  try {
    while (!result) {
      '-';
      n=p->size+p->offset-blk;
      if (n>SC_BLK_CNT)
	n=SC_BLK_CNT;
      if (!n)
	break;
      RBlks(p,buf,blk,1);
      d=buf;
      qq=d;
      if (d[127]==signature) {
	b=d;
	good=TRUE;
	for (j=16;j<BLK_SIZE-4;j++)
	  if (b[j]!=j.u8[0]) {
	    good=FALSE;
	    break;
	  }
	if (good) {
	  result=blk;
	  break;
	}
      }
      blk+=n;
    }
    if (result) {
      blk=result-(SC_BLK_CNT-1);
      if (blk<0) blk=0;
      result=0;
      n=p->size+p->offset-blk;
      if (n>SC_BLK_CNT)
	n=SC_BLK_CNT;
      RBlks(p,buf,blk,n);
      for (i=0;i<n;i++) {
	d=buf+BLK_SIZE*i;
	qq=d;
	if (d[127]==signature && !qq[0]) {
	  b=d;
	  good=TRUE;
	  for (j=16;j<BLK_SIZE-4;j++)
	    if (b[j]!=j.u8[0]) {
	      good=FALSE;
	      break;
	    }
	  if (good) {
	    result=blk+i;
	    size=qq[1];
	    break;
	  }
	}
      }
    }
    if (result) {
      start=result;
      "\nStart  :0x%X Size:0x%X\n",result,size;
      to_go=size;
      blk=result;
      while (to_go && result) {
	'+';
	n=to_go;
	if (n>SC_BLK_CNT)
	  n=SC_BLK_CNT;
	RBlks(p,buf,blk,n);
	for (i=0;i<n;i++) {
	  d=buf+BLK_SIZE*i;
	  qq=d;
	  if (d[127]==signature && qq[0]==blk-result+i &&
	  qq[1]==size) {
	    b=d;
	    for (j=16;j<BLK_SIZE-4;j++)
	      if (b[j]!=j.u8[0]) {
		result=0;
		break;
	      }
	    if (result)
	      contiguous++;
	    else
	      break;
	  } else {
	    result=0;
	    break;
	  }
	}
	to_go-=n;
	blk+=n;
      }
    }
    "Start: 0x%X\n",result;
    if (result) {
      "\nSuccess\n";
      proceed=TRUE;
    } else {
      "\nFailed, but found 0x%X contiguous.\n",contiguous;
      if (contiguous) {
	"Proceed Anyway ";
	proceed=YorN;
      }
    }
  } catch
    Fs->catch_except=TRUE;
 
  Cd("HOME");
  Free(buf);
 
  if (proceed) {
    "New Drive Letter:";
    new_drv_let=ToUpper(GetChar);
    NewLine;
    bdev=&sys_blkdevs[num_blkdevs++];
    bdev->drv_let_base=new_drv_let;
    bdev->blk_size=BLK_SIZE;
    bdev->min_blk=start;
    bdev->max_blk=start+contiguous-1;
    bdev->non_native_drv=drv_let;
    bdev->non_native_offset=start;
    bdev->type=BDT_NON_NATIVE_FILE;
    bdev->flags=BDF_FMT;
    if (!BlkDevAdd(bdev,FALSE))
      PutDefine("ST_FAILED");
    Drv(new_drv_let);
    "File Blk: 0x%X\n",start;
    result=start;
  } else
    result=0;
  return result;
}
#help_index ""