file.cpp

一个简单的虚拟机和虚拟操作系统

#include "StdAfx.h"
#include "file.h"
#include "disk.h"
#include "vm.h"
#include<memory>
using namespace std;

extern VM vm;

FS&fs = vm.fs;


File::File(const CString& name,char*data,int size)
{
	if(size<0)
		throw INDEX_OUT;
	fname = name;
	fsize = size;
	if(size == 0)return;
	int nBlock = size/BLOCK_SIZE;
	if(size%BLOCK_SIZE!=0)
		nBlock++;
	if(nBlock>MAX_BLOCK)
		throw TOO_BIG_FILE;
	if(!fs.allocate(nBlock,iTable))
		throw OUT_OF_DISK;
	for(int i = 0;i<nBlock;i++)
	{
		fs.writeBlock(iTable[i],data);
		data += BLOCK_SIZE;
	}
}
File::~File(void)
{
	if(fsize == 0)return;
	int nBlock = fsize/BLOCK_SIZE;
	if(fsize%BLOCK_SIZE!=0)
		nBlock++;
	fs.free(nBlock,iTable);
}
bool File::read(char*buffer)const
{
	if(fsize == 0)return true;
	int nBlock = getBlockNum();
	int eSize = fsize - (nBlock-1)*BLOCK_SIZE;
	for(int i = 0;i<nBlock-1;i++)
	{
		fs.readBlock(iTable[i],buffer);
		buffer += BLOCK_SIZE;
	}
	memcpy(buffer,fs.getBlock(iTable[nBlock-1]),sizeof(char)*eSize);
	return true;
}
bool File::read(int index,int size,char*buffer)const
{
	if(index+size>fsize||index<0||size<=0)
		return false;

	int sBlock = index/BLOCK_SIZE;
	int eBlock = (index+size)/BLOCK_SIZE;	
	int sSize = BLOCK_SIZE - index%BLOCK_SIZE;
	int eSize = (index+size)%BLOCK_SIZE;

	char c[BLOCK_SIZE];
	fs.readBlock(iTable[0],c);

	if(sBlock == eBlock)
	{
		memcpy(buffer,c+BLOCK_SIZE-sSize,sizeof(char)*size);
		return true;
	}

	memcpy(buffer,c+BLOCK_SIZE-sSize,sizeof(char)*sSize);
	buffer += sizeof(char)*sSize;

	for(int i = sBlock+1;i <= eBlock;i++)
	{
		fs.readBlock(iTable[i],c);
		memcpy(buffer,c,sizeof(char)*BLOCK_SIZE);
		buffer += sizeof(char)*BLOCK_SIZE;
	}
	
	if(eSize!=0)
	{
		fs.readBlock(iTable[eBlock+1],c);
		memcpy(buffer,c,sizeof(char)*eSize);
	}

	return true;
}
bool File::write(int size,const char*buffer)
{
	this->empty();
	if(size<0||size>fs.getFreeSize())
		return false;
	
	if(size == 0)return true;
	int nBlock = size/BLOCK_SIZE;
	if(size%BLOCK_SIZE!=0)
		nBlock++;
	if(nBlock>MAX_BLOCK)
		return false;
	if(!fs.allocate(nBlock,iTable))
		return false;
	for(int i = 0;i<nBlock;i++)
	{
		fs.writeBlock(iTable[i],buffer);
		buffer += BLOCK_SIZE;
	}
	fsize = size;
	return true;
}
bool File::write(int index,int size,const char*buffer)
{
	if(index<0||size<=0||index+size>fs.getFreeSize())
		return false;
	int have = getBlockNum();
	int need = (index+size)/BLOCK_SIZE;
	if((index+size)%BLOCK_SIZE!=0)
		need++;
	if(need>MAX_BLOCK)
		return false;
	fsize = index+size;
	if(need>have)
		if(!fs.allocate(need-have,&iTable[have]))
			return false;

	int sBlock = index/BLOCK_SIZE;
	int eBlock = (index+size)/BLOCK_SIZE;	
	int sSize = BLOCK_SIZE - index%BLOCK_SIZE;
	int eSize = (index+size)%BLOCK_SIZE;

	char c[BLOCK_SIZE];
	fs.readBlock(iTable[0],c);

	if(sBlock == eBlock)
	{
		memcpy(c+BLOCK_SIZE-sSize,buffer,sizeof(char)*size);
		fs.writeBlock(iTable[0],c);
		return true;
	}

	memcpy(c+BLOCK_SIZE-sSize,buffer,sizeof(char)*sSize);
	fs.writeBlock(iTable[0],c);
	buffer += sizeof(char)*sSize;

	for(int i = sBlock+1;i <= eBlock;i++)
	{
		fs.writeBlock(iTable[i],buffer);
		buffer += sizeof(char)*BLOCK_SIZE;
	}
	
	if(eSize!=0)
	{
		memcpy(c,buffer,sizeof(char)*eSize);
		fs.writeBlock(iTable[eBlock+1],c);
	}

	return true;
}
void File::empty()
{
	int nBlock = getBlockNum();
	fs.free(nBlock,iTable);
	fsize = 0;
}
File*File::getCopy()const
{
	File*f = NULL;
	char*buffer = NULL;
	if(fsize>0)
	{
		buffer = new char[fsize];
		this->read(buffer);
	}
	f = new File(fname,buffer,fsize);
	if(buffer!=NULL)
	delete[]buffer;
	return f;
}
void File::save(CArchive&ar)const
{
	ar<<fname<<fsize;
	for(int i = 0;i<MAX_BLOCK;i++)
	  ar<<iTable[i];
}
void File::load(CArchive&ar)
{
	ar>>fname>>fsize;
	for(int i = 0;i<MAX_BLOCK;i++)
	  ar>>iTable[i];
}