pcompute.c

Fdisk 1.2.1 Freedos下硬盘分区软件

	printf("Results of free space calculations after computing spaces between\n  logical drives:\n\n");
	printf("Location of largest free space:  %d\n",pDrive->log_drive_largest_free_space_location);
	printf("Size of largest free space:  %4d\n",pDrive->ext_part_largest_free_space);
	printf("Starting cylinder of largest free space:  %d\n",pDrive->log_drive_free_space_start_cyl);
	printf("Ending cylinder of largest free space:  %d\n",pDrive->log_drive_free_space_end_cyl);
	Pause();
	}
#endif

      /* Determine if there is any free space before the first logical      */
      /* drive in the extended partition.                                   */
      if(pDrive->log_drive[0].num_type!=0)
	{
	if( (pDrive->log_drive[0].start_cyl
	 -pDrive->ptr_ext_part->start_cyl)
	 >pDrive->ext_part_largest_free_space)
	  {
	  pDrive->ext_part_largest_free_space
	   =(pDrive->log_drive[0].start_cyl-pDrive->ptr_ext_part->start_cyl)-1;
	  pDrive->log_drive_free_space_start_cyl
	   =pDrive->ptr_ext_part->start_cyl;
	  pDrive->log_drive_free_space_end_cyl
	   =pDrive->log_drive[0].start_cyl-1;
	  pDrive->log_drive_largest_free_space_location=0;
	  }
	}
      else
	{
	if( (pDrive->log_drive[1].start_cyl
	 -pDrive->ptr_ext_part->start_cyl)
	 >pDrive->ext_part_largest_free_space)
	  {
	  pDrive->ext_part_largest_free_space
	   =(pDrive->log_drive[1].start_cyl
	   -pDrive->ptr_ext_part->start_cyl)-1;
	  pDrive->log_drive_free_space_start_cyl
	   =pDrive->ptr_ext_part->start_cyl;
	  pDrive->log_drive_free_space_end_cyl
	   =pDrive->log_drive[1].start_cyl-1;
	  pDrive->log_drive_largest_free_space_location=0;
	  }
	}

#ifdef DEBUG
      if(debug.determine_free_space==TRUE)
	{
	Clear_Screen(NULL);
	Print_Centered(0,"Determine_Free_Space(int drive) debugging screen 5",BOLD);
	printf("\n\nResults of free space calculations after computing space before\n  the first logical drive:\n\n");
	printf("Location of largest free space:  %d\n",pDrive->log_drive_largest_free_space_location);
	printf("Size of largest free space:  %4d\n",pDrive->ext_part_largest_free_space);
	printf("Starting cylinder of largest free space:  %d\n",pDrive->log_drive_free_space_start_cyl);
	printf("Ending cylinder of largest free space:  %d\n",pDrive->log_drive_free_space_end_cyl);
	}
#endif

      /* Determine if there is any free space after the last logical drive  */
      /* in the extended partition.                                         */
      if( (last_used_partition<23)
       && (pDrive->log_drive[last_used_partition].end_cyl
       <pDrive->ptr_ext_part->end_cyl) )
	{
	if( ( (pDrive->ptr_ext_part->end_cyl + 1)
	 -pDrive->log_drive[last_used_partition].end_cyl)
	 >(pDrive->ext_part_largest_free_space) )
	  {
	  pDrive->ext_part_largest_free_space
	   =(pDrive->ptr_ext_part->end_cyl
	   -pDrive->log_drive[last_used_partition].end_cyl);  // removed -1
	  pDrive->log_drive_free_space_start_cyl
	   =pDrive->log_drive[last_used_partition].end_cyl+1;
	  pDrive->log_drive_free_space_end_cyl
	   =pDrive->ptr_ext_part->end_cyl;
	  pDrive->log_drive_largest_free_space_location=last_used_partition+1;
	  }
	}

#ifdef DEBUG
      if(debug.determine_free_space==TRUE)
	{
	printf("\n\nResults of free space calculations after computing space after\n  the last logical drive:\n\n");
	printf("Location of largest free space:  %d\n",pDrive->log_drive_largest_free_space_location);
	printf("Size of largest free space:  %4d\n",pDrive->ext_part_largest_free_space);
	printf("Starting cylinder of largest free space:  %d\n",pDrive->log_drive_free_space_start_cyl);
	printf("Ending cylinder of largest free space:  %d\n",pDrive->log_drive_free_space_end_cyl);
	Pause();
	}
#endif
      }
    else
      {
      /* If the extended partition is empty. */
      pDrive->ext_part_largest_free_space
       =(pDrive->ptr_ext_part->end_cyl + 1) - pDrive->ptr_ext_part->start_cyl;
      pDrive->log_drive_free_space_start_cyl
       =pDrive->ptr_ext_part->start_cyl;
      pDrive->log_drive_free_space_end_cyl
       =pDrive->ptr_ext_part->end_cyl + 1;

#ifdef DEBUG
      if(debug.determine_free_space==TRUE)
	{
	printf("\n\nThere are not any Logical DOS Drives in the Extended DOS Partition\n\n");
	printf("Location of largest free space:     0\n");
	printf("Size of largest free space:  %d\n",pDrive->ext_part_largest_free_space);
	printf("Starting cylinder of largest free space:  %d\n",pDrive->log_drive_free_space_start_cyl);
	printf("Ending cylinder of largest free space:  %d\n",pDrive->log_drive_free_space_end_cyl);
	Pause();
	}
#endif
      }
    }
}

/* Convert the standard_partition_type to an LBA partition type */
int LBA_Partition_Type_To_Create(int standard_partition_type)
{


  switch(standard_partition_type)
  {

    case 0x0b:  /* Extended int 0x13 FAT 32 */
	return 0x0c;


    case 1:	/* Extended int 0x13 FAT 16 */
    case 4:
    case 6:
	return 0x0e;

    case 5:/* Extended int 0x13 Extended Partition */
	return 0x0f;
    }

  return(standard_partition_type);	/* could be undefined */
}

/* Get the maximum size of the logical drive, in MB. */
long Max_Log_Part_Size_In_MB()
{
  long maximum_partition_size_in_MB;
  long stored_maximum_partition_size_in_MB;

  Partition_Table *pDrive = &part_table[flags.drive_number-0x80];

  Determine_Free_Space();

  maximum_partition_size_in_MB
   = Convert_Cyl_To_MB((pDrive->ext_part_largest_free_space+1)
   , pDrive->total_head+1
   , pDrive->total_sect);

  stored_maximum_partition_size_in_MB = maximum_partition_size_in_MB;

  /* Adjust maximum_partition_size_in_MB depending upon version */
  if( (flags.version==FOUR) && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;
  if( (flags.version==FIVE) && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;
  if( (flags.version==SIX) && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;
  if( (flags.version==W95) && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;
  if( ( (flags.version==W95B) || (flags.version==W98) )
   && (flags.fat32==FALSE) && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;
  if( (flags.fat32==FALSE) && (flags.allow_4gb_fat16==TRUE)
   && (stored_maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB=stored_maximum_partition_size_in_MB;
  if( (flags.fat32==FALSE) && (flags.allow_4gb_fat16==TRUE)
   && (stored_maximum_partition_size_in_MB >= MAXFAT16LARGE) )
   maximum_partition_size_in_MB = MAXFAT16LARGE;

  return(maximum_partition_size_in_MB);
}

/* Get the maximum size of the primary partion, in MB.  */
long Max_Pri_Part_Size_In_MB(int type)
{
  long maximum_partition_size_in_MB;
  long stored_maximum_partition_size_in_MB;

  Partition_Table *pDrive = &part_table[flags.drive_number-0x80];

  Determine_Free_Space();

  maximum_partition_size_in_MB
   = Convert_Cyl_To_MB((pDrive->pri_part_largest_free_space+1)
   , pDrive->total_head+1
   , pDrive->total_sect);

  stored_maximum_partition_size_in_MB = maximum_partition_size_in_MB;

  /* Adjust maximum_partition_size_in_MB depending upon version */
  if( (type!=EXTENDED) && (flags.version==FOUR)
   && (maximum_partition_size_in_MB> MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;

  if( (type!=EXTENDED) && (flags.version==FIVE)
   && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;

  if( (type!=EXTENDED) && (flags.version==SIX)
   && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;

  if( (type!=EXTENDED) && (flags.version==W95)
   && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;

  if( (type!=EXTENDED) && ( (flags.version==W95B) || (flags.version==W98) )
   && (flags.fat32==FALSE) && (maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB = MAXFAT16NORM;

  if( (type!=EXTENDED) && (flags.fat32==FALSE)
   && (flags.allow_4gb_fat16==TRUE)
   && (stored_maximum_partition_size_in_MB > MAXFAT16NORM) )
   maximum_partition_size_in_MB=stored_maximum_partition_size_in_MB;

  if( (type!=EXTENDED) && (flags.fat32==FALSE)
   && (flags.allow_4gb_fat16==TRUE)
   && (stored_maximum_partition_size_in_MB >= MAXFAT16LARGE) )
   maximum_partition_size_in_MB = MAXFAT16LARGE;

  return(maximum_partition_size_in_MB);
}

/* Modify Partition Type */
void Modify_Partition_Type(int partition_number,int type_number)
{
  Partition_Table *pDrive = &part_table[flags.drive_number-0x80];

  if(partition_number<4)
    {
    pDrive->pri_part[partition_number].num_type    =type_number;
    }
  else
    {
    pDrive->log_drive[partition_number-4].num_type =type_number;
    }

  pDrive->part_values_changed=TRUE;
  flags.partitions_have_changed=TRUE;
}

/* Calculate number of cylinders */
unsigned long Number_Of_Cylinders(unsigned long size)
{
  /* unsigned long size has to be in sectors @ 512 bytes/sector */
  Partition_Table *pDrive = &part_table[flags.drive_number-0x80];

  unsigned long num_cyl;
  unsigned long num_head;
  unsigned long size_in_mb = size/2048;

  if (((size_in_mb * 1048576) % 512) != 0) size++;

  num_head = size / pDrive->total_sect;
  if((size % pDrive->total_sect) != 0) num_head++;

  num_cyl = num_head/(pDrive->total_head+1);
  if((num_head % (pDrive->total_head+1)) != 0) num_cyl++;

  return(num_cyl);
}

/* Transfer partition information from one slot to another */
void Primary_Partition_Slot_Transfer(int transfer_type,int source,int dest)
{
   Partition_Table *pDrive = &part_table[flags.drive_number-0x80];

   struct Partition temporaryPartition;

   source--;
   dest--;

   /* Store destination record for later transfer to source location */
   if(transfer_type==SWAP)
     {
     memcpy(&temporaryPartition,&pDrive->pri_part[dest],sizeof(pDrive->pri_part[0]));
     }

   /* Move source record to destination location */
   memcpy(&pDrive->pri_part[dest],&pDrive->pri_part[source],sizeof(pDrive->pri_part[0]));
   

   /* Delete source record */
   memset(&pDrive->pri_part[source],0,sizeof(pDrive->pri_part[0]));

   /* Store original destination record in source location */
   if(transfer_type==SWAP)
     {
     memcpy(&pDrive->pri_part[source],&temporaryPartition,sizeof(pDrive->pri_part[0]));
     }

  pDrive->part_values_changed=TRUE;
  flags.partitions_have_changed=TRUE;
}

/* Compute the partition type to create. */
int Partition_Type_To_Create(unsigned long size_in_mb,
 int requested_partition_type)
{
  /* Note:  Using 0 for requested_partition_type results in a FAT partition
	    value being returned for any partition type.                   */

  int numeric_type;

  if( (requested_partition_type==2)
   || (requested_partition_type==3)
   || (requested_partition_type>=7 && requested_partition_type<=10)
   || (requested_partition_type==13)
   || (requested_partition_type>16) ) return(requested_partition_type);

  /* FAT 12 */
  if(size_in_mb<=16) numeric_type=1;

  /* Small FAT 16 */
  if( (size_in_mb>16) && (size_in_mb<=32) ) numeric_type=4;

  /* Large FAT 16 */
  if(size_in_mb>32) numeric_type=6;

  /* FAT 32 */
  if( (size_in_mb>128) && ( (flags.version==W95B) || (flags.version==W98) )
   && (flags.fat32==TRUE) && (flags.fprmt==TRUE) ) numeric_type=0x0b;

  if( (size_in_mb>512) && ( (flags.version==W95B) || (flags.version==W98) )
   && (flags.fat32==TRUE) ) numeric_type=0x0b;

  return(numeric_type);
}

/* Set Active Partition */
void Set_Active_Partition(int partition_number)
{
  Partition_Table *pDrive = &part_table[flags.drive_number-0x80];
  int index=0;

  do
    {
    if(index==partition_number) pDrive->pri_part[index].active_status=0x80;
    else pDrive->pri_part[index].active_status=0x00;

    index++;
    }while(index<4);

  pDrive->part_values_changed=TRUE;
  flags.partitions_have_changed=TRUE;
}
void Set_Active_Partition_If_None_Is_Active(int partition_number)
{
  int index;
  Partition_Table *pDrive = &part_table[flags.drive_number-0x80];

  for (index=0; index < 4; index++)
    {
    if(pDrive->pri_part[index].active_status & 0x80)
    	return;
    }
  Set_Active_Partition(partition_number);
}