faccess2.c

mp3播放器软件

		}
		m = 0;
		if(LogicA.Cluster == 1)
		{	if(++LogicA.Sector == PbrInfo.RootDirEntry >> 4)
			{	
	Exit:
				if(FirstCluster) 
				{	if(Number) return 0;
					return FileCounter;
				}
				else
				{	if(SearchFile) 	SearchFile = 0;
					else StackPointer--;
					continue;
				}
			}
		}
		else
		{	if(++LogicA.Sector == PbrInfo.SectorPerCluster)
			{	LogicA.Cluster = FindNextCluster(LogicA.Cluster);
				if(LogicA.Cluster >= 0xFFF0) goto Exit;
				LogicA.Sector=0;
			}
		}
		goto Loop;
	}
	if(Number) return 0;
	return FileCounter;
}

//--------------------------------------------------------------------
//open file function
//input: file number
//output:0,error;1,success
//--------------------------------------------------------------------


//-----------------------------------------------------------------
//read file function
//input:FILE pointer,data length and retrun array buffer
//output:
//0,false
// 1,file end
// 2,success
//-----------------------------------------------------------------
char Fread(char *Buffer,unsigned short Len,struct File *fp )
{
	xdata unsigned int temp;
	data unsigned long FileSize;
	FileSize=fp->FileSize1;
	FileSize<<=16;
	FileSize+=fp->FileSize0;
	if((fp->Pointer>=FileSize)||(fp->CurrentClustor==0))return 0;
	LogicA.Cluster=fp->CurrentClustor;
	temp=fp->Pointer%(PbrInfo.BytePerSector*PbrInfo.SectorPerCluster);
	LogicA.Sector=temp/PbrInfo.BytePerSector;
	temp=temp%PbrInfo.BytePerSector;
	while(Len)
	{
		MemoryRw;
		ReadLogicPage(&LogicA);
		McuRw;
		if(temp+Len>=PbrInfo.BytePerSector)
		{
			if(FileSize<=fp->Pointer+PbrInfo.BytePerSector-temp)
			{	if(Buffer != 0x1000 + temp)
					Buffer=memcpy(Buffer,&XBYTE[0x1000+temp],FileSize-fp->Pointer);
				fp->Pointer=FileSize;
				return	1;
			}
			else{
				if(Buffer != 0x1000 + temp)
					Buffer=memcpy(Buffer,&XBYTE[0x1000+temp],PbrInfo.BytePerSector-temp);
				Buffer = Buffer + (PbrInfo.BytePerSector-temp);
				Len-=PbrInfo.BytePerSector-temp;
				fp->Pointer+=PbrInfo.BytePerSector-temp;
				temp=0;
				if(++LogicA.Sector>=PbrInfo.SectorPerCluster)
				{
					LogicA.Cluster=FindNextCluster(fp->CurrentClustor);
					LogicA.Sector=0;
					fp->CurrentClustor=LogicA.Cluster;
				}
			}
		}
		else{
			if(FileSize<=fp->Pointer+Len)
			{	if(Buffer != 0x1000 + temp)
					Buffer=memcpy(Buffer,&XBYTE[0x1000+temp],FileSize-fp->Pointer);
				fp->Pointer=FileSize;
				return	1;
			}
			else{
				if(Buffer != 0x1000 + temp)
					Buffer=memcpy(Buffer,&XBYTE[0x1000+temp],Len);
				fp->Pointer=fp->Pointer+Len;
				return	2;
			}
		}
	}
	return 2;
}	
//---------------------------------------------------------
//search an unused cluster
//input:current cluster
//output: unused cluster
// 0,disk full
//This function fit any disk format------>modified currentcluster type and return type of this function
//---------------------------------------------------------
unsigned int SearchUnusedCluster(unsigned int CurrentCluster)
{
	xdata unsigned int i;
	LogicA.Sector = CurrentCluster >> 8;
	i = CurrentCluster & 0xFF;
	LogicA.Cluster=0;
	//LogicA.Sector=0;
	while(1)
	{
		XBYTE[0x0f] =1;
		ReadLogicPage(&LogicA);
		XBYTE[0x0f] = 0;
		switch(PbrInfo.FatFormat)
		{	case 0x12:
				break;
			case 0x16:
				for(;i < 256; i++)
				{
					#ifdef DEBUG
					M1 = i;
					#endif
					if((XBYTE[0x1200 + (i << 1)] == 0)&&(XBYTE[0x1200 + (i << 1) + 1] == 0))
						if((CurrentCluster != (LogicA.Sector << 8) + i))
							return ((LogicA.Sector << 8) + i);
				}
				i = 0;
				break;
			case 0x32:
				break;
		}
		if(++LogicA.Sector==PbrInfo.NumFatSector) return 0;
	}
}
//-----------------------------------------------------------------
//write data to file
//input:file pointer,data buffer,length
//output:1---success.  0---failure
//This function only fit disk of fat16 format
//-----------------------------------------------------------------
bit Fwrite(struct File *fp)
{	xdata unsigned long FileSize;
	xdata unsigned int ClusterTemp;

	if(fp->FirstClustor == 0)
	{	fp->FirstClustor = SearchUnusedCluster(0);
		if(!fp->FirstClustor) return 0;
		fp->CurrentClustor = fp->FirstClustor;
		LogicA.Cluster = fp->CurrentClustor;
		LogicA.Sector = 0;
		ReqDiskSpace(LogicA.Cluster,0,1,0);
		MemoryRw;
		WriteLogicPage(&LogicA);		//write data to file
		McuRw;
		fp->FileSize0 = 512;
		fp->FileSize1 = 0;
		return 1;
	}

	FileSize = fp->FileSize1;
	FileSize <<= 16;
	FileSize |= fp->FileSize0;

	LogicA.Cluster = fp->CurrentClustor;
	LogicA.Sector = (FileSize % (PbrInfo.BytePerSector*PbrInfo.SectorPerCluster))/PbrInfo.BytePerSector;
	if(LogicA.Sector == 0)
	{	LogicA.Cluster = SearchUnusedCluster(fp->CurrentClustor);
		if(LogicA.Cluster == 0) return 0;
		ReqDiskSpace(LogicA.Cluster,0,1,0);
		LogicA.Sector = 0;
	}
	#ifdef DEBUG
	M1 = LogicA.Cluster;
	M1 = fp->CurrentClustor;
	#endif
	MemoryRw;
	WriteLogicPage(&LogicA);		//write data to file
	McuRw;
	#ifdef DEBUG
	M1 = LogicA.Cluster;
	M1 = LogicA.Sector;

	MemoryRw;
	ReadLogicPage(&LogicA);
	McuRw;
	#endif

	if(fp->CurrentClustor != LogicA.Cluster)
	{	ClusterTemp = LogicA.Cluster;
		//LogicA.Sector = LogicA.Cluster >> 8;	//find out fat sector  //fat16
		LogicA.Sector = fp->CurrentClustor >> 8;
		LogicA.Cluster = 0;
		#ifdef DEBUG
		M1 = LogicA.Cluster;
		M1 = fp->CurrentClustor;
		M1 = ClusterTemp;
		#endif
		MemoryRw;
		ReadLogicPage(&LogicA);
		McuRw;
		XBYTE[0x1000 + (fp->CurrentClustor&0xFF) * 2 + 1] = ClusterTemp>> 8;	//fat16
		XBYTE[0x1000 + (fp->CurrentClustor&0xFF) * 2] = ClusterTemp&0xFF;		//fat16
		fp->CurrentClustor = ClusterTemp;
		MemoryRw;
		WriteFat(LogicA.Sector);//write data to fat
		McuRw;
		#ifdef DEBUG
		MemoryRw;
		ReadLogicPage(&LogicA);
		McuRw;
		#endif
	}
	FileSize += 512;
	fp->FileSize1=(FileSize>>16);
	fp->FileSize0=FileSize;
	return 1;
}

//------------------------------------------------------------------
//close file function
//input: file pointer,file name
//output:none
//This function fit any disk format
//------------------------------------------------------------------
void Fclose(struct File *fp)
{	
	xdata unsigned int i,j,k;
	xdata unsigned long dd,cc;
	if(fp->FirstClustor == 0) return;
	LogicA.Cluster = (fp->Pointer>>16);
	LogicA.Sector = fp->Pointer&0xff;
	i = fp->Pointer >> 8;
	i &=0x00ff;
	//write fcb
	MemoryRw;
	ReadLogicPage(&LogicA);		//read file entry information to buffer one
	McuRw;
	XBYTE[0x1000 + FILE_HEAD_CLUSTER + (i << 5) +1] = fp->FirstClustor >> 8;	//modify file entry first culuster
	XBYTE[0x1000 + FILE_HEAD_CLUSTER + (i << 5)] = fp->FirstClustor;
	XBYTE[0x1000 + (i << 5) + FILESIZE + 3] = fp->FileSize1 >> 8;	//modify file entry file size
	XBYTE[0x1000 + (i << 5) + FILESIZE + 2] = fp->FileSize1;
	XBYTE[0x1000 + (i << 5) + FILESIZE + 1] = fp->FileSize0 >> 8;
	XBYTE[0x1000 + (i << 5) + FILESIZE] = fp->FileSize0;

	/*MemoryRw;
	WriteFcb(LogicA.Sector);		//write file entry information from buffer one to disk
	McuRw;*/
	cc = DataBase.Block*32 + DataBase.Page + LogicA.Sector;
	dd = LogicA.Cluster - 2;
	dd *= PbrInfo.SectorPerCluster;
	dd += cc;
	dd  = dd + (dd/(32*496))*512;
	j = dd>>5;//Block addr
	k = dd%32;//page addr
	BackupData(j,k,0);
	//write fat
	LogicA.Cluster = 0;
	LogicA.Sector = fp->CurrentClustor >> 8;
	i = fp->CurrentClustor&0xFF;
	#ifdef DEBUG
	M1 = LogicA.Sector;
	M1 = i;
	#endif
	MemoryRw;
	ReadLogicPage(&LogicA);		//read file entry information to buffer one
	McuRw;
	switch(PbrInfo.FatFormat)
	{	case 0x12:
			break;
		case 0x16:
			XBYTE[0x1000 + (i << 1) +1] = 0xFF;
			XBYTE[0x1000 + (i << 1)] = 0xFF;
			break;
		case 0x32:
			break;
	}
	#ifdef DEBUG
	M1 = LogicA.Cluster;
	M1 = LogicA.Sector;
	#endif
	MemoryRw;
	WriteFat(LogicA.Sector);	//write file cluster pointer information from buffer one to disk
	McuRw;
	#ifdef DEBUG
	MemoryRw;
	ReadLogicPage(&LogicA);
	McuRw;
	#endif
}
//---------------------------------------------
//Create a file fuction
//input:File pointer;
//output:0,faiture,enough space
// 1,success
//mode=1 create directory,mode = 0 create file
//---------------------------------------------
bit Fcreat(struct File *fp,unsigned char *Name,unsigned int FirstCluster)
{
	xdata unsigned char k=0;
	xdata unsigned int i,j;
	xdata unsigned long dd,cc;
	
	//if(OpenFileByName(fp, Name,FirstCluster)) return 0;
	//search  null space for creating a file entries in boot directory zoon.
	LogicA.Cluster=FirstCluster;
	LogicA.Sector=0;
	while(1)
	{
		MemoryRw;
		ReadLogicPage(&LogicA);
		McuRw;
		for(i=0;i<16;i++)
		{	if((XBYTE[0x1000+32*i]==0) || (XBYTE[0x1000+32*i]==0xE5))
			{
				for(k=0;k<12;k++)
					XBYTE[0x1000 + (i << 5) + k] = ' ';
				k=strpos(Name,'.');
				if(k != 0xFF)
				{
					if((strlen(Name) > 12)||(strlen(Name + k + 1) > 3)) return 0;
					strncpy(&XBYTE[0x1000 + (i << 5)],Name,k);		//write file name
					strcpy(&XBYTE[0x1000 + (i << 5) + 8],Name +  k + 1);	//write file extent name
				}
				else
				{
					if(strlen(Name) > 8) return 0;
					strcpy(&XBYTE[0x1000 + (i << 5)],Name);			//write file name
				}
				XBYTE[0x1000 + (i<<5) + FILE_ATTRIB] = 0x20;
				cc = DataBase.Block*32 + DataBase.Page + LogicA.Sector;
				dd = LogicA.Cluster - 2;
				dd *= PbrInfo.SectorPerCluster;
				dd += cc;
				dd  = dd + (dd/(32*496))*512;
				j = dd>>5;//Block addr
				k = dd%32;//page addr
				BackupData(j,k,0);
				fp->FirstClustor = 0;
				fp->Pointer = LogicA.Cluster;
				fp->Pointer <<= 16;
				i <<= 8;
				i |= LogicA.Sector;
				fp->Pointer |= i;
				return 1;
			}
		}
		if(++LogicA.Sector == PbrInfo.SectorPerCluster)
		{
			LogicA.Cluster = FindNextCluster(LogicA.Cluster); 			
			if(LogicA.Cluster > 0xfff0)return FALSE;
			LogicA.Sector = 0;
		}
		/*switch(PbrInfo.FatFormat)
		{	case 0x12:
			case 0x16:
				if(++LogicA.Sector == PbrInfo.RootDirEntry >> 4)	return 0;
				break;
			case 0x32:
				break;
		}*/
	}
}