main.cpp

模拟unix文件系统的功能

	if((parent!=-2)&&(parent!=-1))                     //父目录存在
	{
		int decide;
		decide=search(Get_Name(path),parent);          //判断路径是否存在
        if(decide!=-1)                                 //重名目录
		{
			cout<<"不能创建已存在的目录!"<<endl;
			return -1;
		}
		else
		{ 
			if(Dir_Init(parent,Get_Name(path))!=-1)     //使用Dir_Init函数
			{
				return parent;
            }
		}	
	}
	if(parent==-1)
	{
		cout<<"不能创建与根目录同名的目录!"<<endl;       //与根目录同名
	    return -1;
	}
	cout<<"目录创建失败!"<<endl;
    return -1;
}

/*******************************************************************************************
                       删除目录rd主函数，使用递归
			       要删目录不空时，要给出提示是否要删除		
*******************************************************************************************/
int rd(char *path)
{
	int parent,decide=-1;                        //记录下parent，便于递归
	int Temp_Index;
	parent=Get_Parent(path);
	char *panduan=new char;
	if(parent==-1)                               //根目录 
	{
		cout<<"不可删除根目录!"<<endl;
		return -1;
	}
	if(parent!=-2)                               //parent存在，判断要删除的目录是否存在
	{
		decide=search(Get_Name(path),parent);
		if((decide!=-1)&&(Inode[decide].decide==0))
		{
			Temp_Index=decide;
		    if(Inode[Temp_Index].Child_Num>0)     //要删除的目录不为空
			{
			     cout<<"Really Delete?Y/N"<<endl;
                 cin>>panduan;
			}
			//确定要删除该目录
            if(!strcmp(panduan,"Y")||(!strcmp(panduan,"y"))||Inode[Temp_Index].Child_Num==0)
			{
			     Del_Dir(Temp_Index,parent);      //使用Del_Dir函数来实现删除
				 return 1;
			}
		}
	}
cout<<"删除失败!"<<endl;
return -1;
}

/*******************************************************************************************
                                删除函数Del_Dir
			       使用递归,成功返回被删节点的Inode号,失败返回-1		
*******************************************************************************************/
void Del_Dir(int Temp_Index,int parent)
{
	char *path=new char;
	int Index_Other;
		while(Temp_Index!=parent)
		{
			if((Inode[Temp_Index].Child_Num==0)&&(Inode[Temp_Index].decide==0))   //空目录
			{
				super.Free_Inode++;                    //修改超级块信息与Bitmap
	            Inode_Bitmap[Temp_Index]=0;
                
                Inode[Temp_Index].decide=-1;           //修改Inode区信息
                Inode[Temp_Index].index=Temp_Index;
                for(int k=0;k<15;k++)                  //将每个目录的子节点赋为-1
				{
					Inode[Temp_Index].child[k]=-1;
				}
                
	            //修改父节点信息
                Index_Other=Search_Other(Inode[Temp_Index].name,parent);
	            Inode[parent].Child_Num--;             //子节点数-1
                Inode[parent].child[Index_Other]=-1;   
                
	            Temp_Index=parent;
			} 
			if(Inode[Temp_Index].decide==1)                                        //文件
			{

				strcpy(path,Whole_Path(Temp_Index));
				del(path);

				Temp_Index=parent;
			}
            if((Inode[Temp_Index].decide==0)&&(Inode[Temp_Index].Child_Num>0))     //非空目录
            {
				
				for(int j=0;j<15;j++)
				{
					if(Inode[Temp_Index].child[j]!=-1)
					{
						Del_Dir(Inode[Temp_Index].child[j],Temp_Index);
					}
				}
                //Del_Null_Dir(Temp_Index,parent);
				{
	                super.Free_Inode++;                    //修改超级块信息与Bitmap
	                Inode_Bitmap[Temp_Index]=0;
                
                    Inode[Temp_Index].decide=-1;           //修改Inode区信息
                    Inode[Temp_Index].index=Temp_Index;
                    for(int k=0;k<15;k++)                  //将每个目录的子节点赋为-1
					{
						Inode[Temp_Index].child[k]=-1;
					}
                
	                //修改父节点信息
	                Index_Other=Search_Other(Inode[Temp_Index].name,parent);
	                Inode[parent].Child_Num--;
                    Inode[parent].child[Index_Other]=-1;
				} 
				Temp_Index=parent;
			}
		}
}

		
/*******************************************************************************************
                             改变工作目录cd主函数
					改变当前工作目录，目录不存在时给出出错信息			
*******************************************************************************************/
int cd(char*path)
{
	int parent,decide;
	parent=Get_Parent(path);
	if(parent==-1)                                //根目录
	{
		curr=0;                                   //当前索引值
        Curr_Inode=&Inode[curr];                  //当前inode索引指针
        strcpy(current,Inode[curr].name);
		return 0;
	}
	if(parent==-2)                                //父目录不存在
	{
		cout<<"未找到该目录!"<<endl;
	    return -1;
	}
    decide=search(Get_Name(path),parent);
    if((decide!=-1)&&(Inode[decide].decide==0))   //路径存在且是目录的路径
	{
		curr=decide;
		Curr_Inode=&Inode[curr];
        strcpy(current,Whole_Path(curr));
		return curr;
    }
	else
	{
		cout<<"未找到该目录!"<<endl;
		return -1;
	}
}

/*******************************************************************************************
                      打印函数,index指示要打印的节点索引号	 			
*******************************************************************************************/

void print(int index)              
{
	int length;
    if(Inode[index].decide==0)                     //打印目录信息               
	{
		cout<<Inode[index].name;
        for(length=strlen(Inode[index].name);length<30;length++)
        {
			cout<<" ";
		}
		cout<<"<Dir>                       ";
        cout<<Inode[index].ctime.wYear<<"-"<<Inode[index].ctime.wMonth
		<<"-"<<Inode[index].ctime.wDay<<"  "<<Inode[index].ctime.wHour
		<<":"<<Inode[index].ctime.wMinute<<":"<<Inode[index].ctime.wSecond<<endl;
	}
	if(Inode[index].decide==1)                     //打印文件信息
	{
		cout<<Inode[index].name;
        for(length=strlen(Inode[index].name);length<30;length++)
        {
			cout<<" ";
		}
		cout<<"<File>                      ";
        cout<<Inode[index].ctime.wYear<<"-"<<Inode[index].ctime.wMonth
		<<"-"<<Inode[index].ctime.wDay<<"  "<<Inode[index].ctime.wHour
		<<":"<<Inode[index].ctime.wMinute<<":"<<Inode[index].ctime.wSecond<<endl;
	}
}


/*******************************************************************************************
                             显示目录信息dir主函数
				显示子目录信息，可显示指定目录，当前目录及全部目录	 			
*******************************************************************************************/

int dir(char *path)
{
	int i,j,parent,decide;
	if(!strcmp(path,"/s"))                       //dir /s命令，显示所有文件和目录
	{
		for(i=1;i<15;i++)
		{
			if((Inode[i].decide==0)||(Inode[i].decide==1))
			{
				cout<<Whole_Path(i);             //显示完整路径
			    for(j=strlen(Whole_Path(i));j<30;j++)
				{
					cout<<" ";
				}
				if(Inode[i].decide==0)           //显示是文件类型还是目录类型
				cout<<"<Dir>                       ";
				else
				cout<<"<File>                      ";
				cout<<Inode[i].ctime.wYear<<"-"<<Inode[i].ctime.wMonth
					<<"-"<<Inode[i].ctime.wDay<<"  "<<Inode[i].ctime.wHour
					<<":"<<Inode[i].ctime.wMinute<<":"<<Inode[i].ctime.wSecond<<endl;
            }
		}
		return 1;

	}
	else
	{
		parent=Get_Parent(path);
        if(parent==-1)                                           //dir L:命令
        {
			for(i=0;i<15;i++)
			{
				if(Inode[0].child[i]!=-1)
				{
                     print(Inode[0].child[i]);                   //打印
				}
			}
			return 1;
		}
		if((parent!=-1)&&(parent!=-2))
		{
			decide=search(Get_Name(path),parent);
			if((decide!=-1)&&(Inode[decide].decide==0))
			{
				for(i=0;i<15;i++)
				{
					if(Inode[decide].child[i]!=-1)
					{
						print(Inode[decide].child[i]);
					}
				}
				return decide;
			}
		}
	}
	cout<<"dir命令失败!"<<endl;
    return -1;
}


/*******************************************************************************************
                      判断是相对路径还是绝对路径还是根目录
			        相对路径返回2，绝对路径返回1,根目录返回0		   
*******************************************************************************************/

int decide(char*path)
{
	char*temp=new char;
	temp=strchr(path,'/');                
	if(!strcmp(path,"L:"))                //根目录
	{
	    return 0;                         //path为根目录
	}
	else
	{
	    if(temp)                          //相对路径
		{
		    return 2;
		}
        else                              //绝对路径    
        {
			return 1;
        }
	}
}


/*******************************************************************************************
                       对文件进行初始化,返回inode索引节点					
*******************************************************************************************/  

int File_Init(int parent,char*path,char *input)
{
    if(panduan(path,'/')||panduan(path,':'))             //判断命名中是否存在'/'或'.'
	{
		cout<<"目录名中含有字符/:"<<endl;
		return -1;
	}
	fstream iof("C:\\LinuxOs.dat",ios::binary|ios::in|ios::out);
	int Input_Length;                                    //记录文件长度
	int Req_Block_Num;
	int i,j,k;
	for(i=1;i<Inode_Num;i++)
	{
		if(Inode_Bitmap[i]==0)                           //有空闲Inode区
		{
			for(j=0;j<15;j++)
			{
				if(Inode[parent].child[j]==-1)           //父节点的子目录数未满
				{
                    Input_Length=strlen(input);
                    Req_Block_Num=Input_Length/Block_Size+1;
                    if(super.Free_Block>=Req_Block_Num)  //空闲磁盘块数足够
                    {
						for(k=533;k<Block_Num;k++)
						{
							if(Block_Bitmap[k]==0)       //第一个空闲磁盘块
							{
								iof.seekp(k*Block_Size,ios::beg);
                                while(*input!='\0')
								{
									iof.write((char*)&(*input),sizeof(char));//写文件
				                    input++;
								}
								break;
							}
						}
						//初始化superblock及两个bitmap
						super.Free_Inode--;
						super.Free_Block=super.Free_Block-Req_Block_Num;
                        Inode_Bitmap[i]=1;
                        for(int num=0;num<Req_Block_Num;num++)
						{
							Block_Bitmap[k+num]=1;
						}

						//初始化inode节点
                        Inode[i].decide=1;                  //文件的标志
			            strcpy(Inode[i].name,path);
                        Inode[i].First_Block=k;             //文件占用的第一块磁盘块
                        Inode[i].length=Input_Length+1;
                        Inode[i].index=i;
                        Inode[i].parent=parent;
                        Inode[i].Child_Num=0;
                        GetLocalTime(&Inode[i].ctime);      //获得当前时间

			            //初始化文件的父节点
			            Inode[parent].Child_Num++;
					    Inode[parent].child[j]=i;
				        return i;
					    
				}
			}
		}
	}
}
	return -1;
		
}

/*******************************************************************************************
                        创建文件newfile主函数
			  创建成功返回父目录Inode索引号，创建失败返回-1			
*******************************************************************************************/

int newfile(char *path)
{
	int parent;
	parent=Get_Parent(path);
	char*input=new char;
	if((parent!=-2)&&(parent!=-1))                     //父目录存在
	{
		int decide;
		decide=search(Get_Name(path),parent);
        if(decide!=-1)                                 //有同名文件或目录
		{
			cout<<"有重名文件或目录!"<<endl;
			return -1;
		}
		else
		{
			cout<<"Please Input Someting Into The File!"<<endl;//输入文件内容
			cin>>input;
			if(File_Init(parent,Get_Name(path),input)!=-1)
			{
				return parent;
            }		
		}	
	}
     cout<<"新建文件失败!"<<endl;
     return -1;
}

/*******************************************************************************************
                            打开文件cat主函数
				    成功时显示文件内容,失败时提示出错信息
*******************************************************************************************/

char* cat(char *path)
{
	int i=0;
	fstream iof("C:\\LinuxOs.dat",ios::binary|ios::in|ios::out);
	int parent;
	parent=Get_Parent(path);
	char *output=new char;
	if((parent!=-2)&&(parent!=-1))                         //父目录存在
	{
		int decide;
		decide=search(Get_Name(path),parent);
		if((decide!=-1)&&Inode[decide].decide==1)          //路径存在且是文件路径
		{
            //打开First_Block所指位置
			iof.seekg((Inode[decide].First_Block)*Block_Size,ios::beg);
			iof.get(output,Inode[decide].length,'\n');     //读出文件信息
            return output;
		}
	}