mem-ffs.c

mmc_sd_memory_card_driver_sample_project_files.zip spi接口的sd card driver 示例

	## (################# == #)
	{
		//-------------------------------------------------
		//----- OFFSET IS ZERO - SET TO START OF FILE -----
		//-------------------------------------------------
		#############>############### = ######################(############);
		#############>############## = #;
		#############>############ = #;
		#############>######################## = #;

	}
	####
	{
		//----- NON-ZERO VALUE -----

		//--------------------------------------------------------------------------------------------------------------------------------------------
		//----- IF NEW LOCATION IS WITHIN CURRENT CLUSTER THEN DO ADJUSTMENT AVOIDING HAVING TO READ EVERY FAT CLUSTER ENTRY FROM THE FILE START -----
		//--------------------------------------------------------------------------------------------------------------------------------------------

		## (################# == #############>########################)
		{
			//----- NEW POSITION IS SAME AS EXISTING POSITION -----
			################## = #;
		}
		#### ## (################# < #############>########################)
		{
			//----- NEW POSITION IS BEFORE CURRENT POSITION -----
			## (
				(#############>######################## # #################) <
				(#############>############ + (#############>############## * ####################))
				)
			{
				//IN SAME CLUSTER

				################## = #;
				//file_pointer->current_cluster = file_pointer->current_cluster;			//Stays the same
				
				####### = #################;
				################# = (#############>######################## # #################);
				#############>######################## = #######;

				##### (################# >= ####################)
				{
					################# #= ####################;
					## (#############>##############)
						#############>################;
					####
						################## = #;				//Error!
				}


				#############>############ #= (####)#################;
				## (#############>############ >= ####################)		//Check for overflow into previous sector
				{
					#############>############ += ####################;		//(Yes the '+' is correct!)
					## (#############>##############)
						#############>################;
					####
						################## = #;				//Error!
				}
			}
			####
			{
				//IN DIFFERENT CLUSTER
				################## = #;
			}
		}
		####
		{
			//----- NEW POSITION IS AFTER CURRENT POSITION -----
			## (
				(################# # #############>########################) <
				(################# # (#############>############ + (#############>############## * ####################)))
				)
			{
				//IN SAME CLUSTER

				################## = #;
				//file_pointer->current_cluster = file_pointer->current_cluster;			//Stays the same

				####### = #################;
				################# = (################# # #############>########################);
				#############>######################## = #######;

				##### (################# >= ####################)
				{
					################# #= ####################;
					## (#############>############## < ###################)
						#############>##############++;
					####
						################## = #;				//Error!
				}

				#############>############ += (####)#################;
				## (#############>############ >= ####################)
				{
					#############>############ #= ####################;
					## (#############>############## < ###################)
						#############>##############++;
					####
						################## = #;				//Error!
				}
			}
			####
			{
				//IN DIFFERENT CLUSTER
				################## = #;
			}
		}
		


		## (##################)
		{
			//-------------------------------------------------------------------------------------------
			//----- NEW LOCATION IS NOT IN THE CURRENT CLUSTER - FIND IT FROM THE START OF THE FILE -----
			//-------------------------------------------------------------------------------------------
			#############>############### = ######################(############);
			#############>############## = #;
			#############>######################## = #################;
	
			//KEEP MOVING TO NEXT CLUSTER UNTIL WE'RE IN THE REQURIED CLUSTER
			##### (################# >= #################)
			{
				################# #= #################;
				#############>############### = #######################(#############>###############);
			}
			//KEEP MOVING TO NEXT SECTOR UNTIL WE'RE IN THE REQURIED SECTOR (OF THE ALREADY FOUND CLUSTER)
	
			##### (################# >= ####################)
			{
				################# #= ####################;
				#############>##############++;
			}
			//STORE THE CURRENT BYTE NUMBER
			#############>############ = (####)#################;
		}
	}

	#############>#####.####.########### = #;			//The EOF flag is cleared when this function sucessfully is called
	######(#);


}



//************************************************
//************************************************
//********** MOVE THE FILE BYTE POINTER **********
//************************************************
//************************************************
//(The value returned by ffs_getpos intended to be file system specific and to be used with this function.  However as the position type is recomended
//to be a long we just use the ffs_ftell function as a long doesn't give us enough space to store everything we need for the low level position)
//Returns
//	0 if successful, 1 otherwise
int ffs_fsetpos (FFS_FILE *file_pointer, long *position)
{
	//----- EXIT IF THIS FILE ISN'T ACTUALLY OPEN -----
	## (#############>#####.####.############ == #)
		######(#);

	#############>#####.####.########### = #;			//Clear the end of file flag

	######(#########(############, *########, ############));
}



//******************************************************
//******************************************************
//********** GET THE CURRENT POSITION IN FILE **********
//******************************************************
//******************************************************
//Get the current file position.
long ffs_ftell (FFS_FILE *file_pointer)
{

	//----- EXIT IF THIS FILE ISN'T ACTUALLY OPEN -----
	## (#############>#####.####.############ == #)
		######(#);

	//----- RETURN THE CURRENT POSITION -----
	## (#############>#####.####.#######################)
		######((####)#############>######################## + #);
	####
		######((####)#############>########################);
}



//******************************************************
//******************************************************
//********** GET THE CURRENT POSITION IN FILE **********
//******************************************************
//******************************************************
//(The value returned is intended to be file system specific and only to be used with fsetpos.  However as the position type is recomended
//to be a long we just use the ffs_ftell function as a long doesn't give us enough space to store everything we need for the low level position)
//Returns
//	0 if successful, 1 otherwise
int ffs_fgetpos (FFS_FILE *file_pointer, long *position)
{


	//----- EXIT IF THIS FILE ISN'T ACTUALLY OPEN -----
	## (#############>#####.####.############ == #)
		######(#);

	//----- RETURN THE CURRENT POSITION -----
	*######## = #########(############);
	######(#);

}




//***********************************************************************
//***********************************************************************
//********** SET POSITION TO BEGINNING OF FILE AND CLEAR FLAGS **********
//***********************************************************************
//***********************************************************************
void ffs_rewind (FFS_FILE *file_pointer)
{

	######### (############, #, ############);

	#############>#####.####.############ = #;
}





//****************************************
//****************************************
//********** WRITE BYTE TO FILE **********
//****************************************
//****************************************
//Data is converted to a byte before writing (int type is specified by ANSI-C)
//If there are no errors the written character is returned. If an error occurs, EOF is returned.

//#define	ffs_putc(data, file_pointer)	ffs_fputc(data, file_pointer)			//Defined in header file - these 2 functions are equivalent

int ffs_fputc (int data, FFS_FILE *file_pointer)
{
	##### #######;
	#### *##############;

	//-------------------------------------------------
	//----- EXIT IF THIS FILE ISN'T ACTUALLY OPEN -----
	//-------------------------------------------------
	## (#############>#####.####.############ == #)
		######(#######);


	//---------------------------------------------------------------------------------------------------------------------------
	//----- CHECK THAT WRITING IN THIS POSITION IS PERMITTED FOR THE FOPEN MODE THAT WAS SPECIFIED WHEN THE FILE WAS OPENED -----
	//---------------------------------------------------------------------------------------------------------------------------
	## (#############>#####.####.############### == #)
	{
		//----- WRITING IS NOT PERMITTED -----
		#############>#####.####.############ = #;
		######(#######);
	}
	## (#############>#####.####.#################)
	{
		//----- APPEND MODE - WRITING MAY ONLY OCCUR AS NEW BYTES AT THE END OF THE FILE -----
		####### = #############>########################;
		## (#############>#####.####.#######################)
		{
			#######++;
		}

		## (####### < #############>#########)
		{
			//CURRENTLY POINTING TO WITHIN FILE - SET TO END OF FILE
			#########(############, #, ############);
		}
	}


	//-----------------------------------------------------------------------
	//----- CHECK FOR NEED TO MOVE TO NEXT BYTE POSITION BEFORE WRITING -----
	//-----------------------------------------------------------------------
	## (#############>#####.####.#######################)
	{
		//----- INCREMENT BYTE COUNT -----
		#############>########################++;

		#############>############++;
		
		## (#############>############ >= ####################)
		{
			//----- MOVE TO NEXT SECTOR -----
			#############>############ = #;

			#############>##############++;

			## (#############>############## >= ###################)
			{
				//----- MOVE TO NEXT CLUSTER -----
				#############>############## = #;

				####### = #########################();
				## (####### == ##########)			//0xffffffff = no empty cluster found
				{
					//NOT ENOUGH SPACE FOR ANY MORE OF FILE
					###### = #;
					#############>#####.####.########### = #;
					######(#######);
				}

				//UPDATE THE CURRENT CLUSTER TO LINK TO THE NEXT CLUSTER
				############################### (#############>###############, #######);

				//UPDATE THE NEXT CLUSTER WITH THE END OF FILE MARKER
				############################### (#######, ##########);

				#############>############### = #######;
			}
		}

		#############>#####.####.####################### = #;
	}

	
	//-------------------------------------------------------------
	//----- CHECK FOR NEED TO LOAD CURRENT SECTOR INTO BUFFER -----
	//-------------------------------------------------------------
	####### = (
				((#############>############### # #) * ###################) +
				(#####)#############>############## +
				######################
				);
	## (####################### != #######)
	{
		#########################(#######);
	}


	//--------------------------
	//----- WRITE THE BYTE -----
	//--------------------------
	############## = &##############################[#] + #############>############;
	*############## = (####)(#### & ######);


	//---------------------------------------------------------------------------
	//----- ADJUST FILE SIZE IF WE HAVE JUST WRITTEN TO THE END OF THE FILE -----
	//---------------------------------------------------------------------------
	## (#############>######################## >= #############>#########)
	{
		#############>#########++;
		#############>#####.####.##################### = #;
	}


	//------------------------------------------------------------------------
	//----- FLAG THAT WE NEED TO MOVE ON 1 BYTE NEXT TIME ACCESS IS MADE -----
	//------------------------------------------------------------------------
	//(we do this instead of incrementing now in case we have just done the last byte of the file)
	#############>#####.####.####################### = #;

	//----------------------------------------------------------
	//----- FLAG THAT THE BUFFER NEEDS WRITING TO THE CARD -----
	//----------------------------------------------------------
	################################ = #;

	//-----------------------------------------------
	//----- EXIT WITH THE BYTE THAT WAS WRITTEN -----
	//-----------------------------------------------
	######(####);
}




//**********************************************
//**********************************************
//********** READ NEXT BYTE FROM FILE **********
//**********************************************
//**********************************************
//The byte read is returned as an int value (int type is specified by ANSI-C)
//If the End Of File has been reached or there has been an error reading, the function returns EOF.

//#define ffs_getc(file_pointer)		ffs_fgetc(file_pointer)			//Defined in header file - these 2 functions are equivalent

int ffs_fgetc (FFS_FILE *file_pointer)
{
	#### ####;
	##### #######;
	#### *##############;

	//-------------------------------------------------
	//----- EXIT IF THIS FILE ISN'T ACTUALLY OPEN -----
	//-------------------------------------------------
	## (#############>#####.####.############ == #)
		######(#######);

	//---------------------------------------------------------------------------------------------------------------------------
	//----- CHECK THAT READING IN THIS POSITION IS PERMITTED FOR THE FOPEN MODE THAT WAS SPECIFIED WHEN THE FILE WAS OPENED -----