自学教程：C++ DOS_SetError函数代码示例

bool DOS_CreateFile(char const * name,Bit16u attributes,Bit16u * entry,bool fcb) {    // Creation of a device is the same as opening it    // Tc201 installer    if (DOS_FindDevice(name) != DOS_DEVICES)        return DOS_OpenFile(name, OPEN_READ, entry, fcb);    LOG(LOG_FILES,LOG_NORMAL)("file create attributes %X file %s",attributes,name);    char fullname[DOS_PATHLENGTH];    Bit8u drive;    DOS_PSP psp(dos.psp());    if (!DOS_MakeName(name,fullname,&drive)) return false;    /* Check for a free file handle */    Bit8u handle=DOS_FILES;    Bit8u i;    for (i=0; i<DOS_FILES; i++) {        if (!Files[i]) {            handle=i;            break;        }    }    if (handle==DOS_FILES) {        DOS_SetError(DOSERR_TOO_MANY_OPEN_FILES);        return false;    }    /* We have a position in the main table now find one in the psp table */    *entry = fcb?handle:psp.FindFreeFileEntry();    if (*entry==0xff) {        DOS_SetError(DOSERR_TOO_MANY_OPEN_FILES);        return false;    }    /* Don't allow directories to be created */    if (attributes&DOS_ATTR_DIRECTORY) {        DOS_SetError(DOSERR_ACCESS_DENIED);        return false;    }    bool foundit=Drives[drive]->FileCreate(&Files[handle],fullname,attributes);    if (foundit) {        Files[handle]->SetDrive(drive);        Files[handle]->AddRef();        if (!fcb) psp.SetFileHandle(*entry,handle);        return true;    } else {        if(!PathExists(name)) DOS_SetError(DOSERR_PATH_NOT_FOUND);        else DOS_SetError(DOSERR_FILE_NOT_FOUND);        return false;    }}

bool DOS_MakeDir(char const * const dir) {	Bit8u drive;char fulldir[DOS_PATHLENGTH];	size_t len = strlen(dir);	if(!len || dir[len-1] == '//') {		DOS_SetError(DOSERR_PATH_NOT_FOUND);		return false;	}	if (!DOS_MakeName(dir,fulldir,&drive)) return false;	if(Drives[drive]->MakeDir(fulldir)) return true;	/* Determine reason for failing */	if(Drives[drive]->TestDir(fulldir)) 		DOS_SetError(DOSERR_ACCESS_DENIED);	else		DOS_SetError(DOSERR_PATH_NOT_FOUND);	return false;}

bool DOS_FreeMemory(Bit16u segment) {//TODO Check if allowed to free this segment	if (segment < DOS_MEM_START+1) {		LOG(LOG_DOSMISC,LOG_ERROR)("Program tried to free %X ---ERROR",segment);		DOS_SetError(DOSERR_MB_ADDRESS_INVALID);		return false;	}      	DOS_MCB mcb(segment-1);	if ((mcb.GetType()!=0x4d) && (mcb.GetType()!=0x5a)) {		DOS_SetError(DOSERR_MB_ADDRESS_INVALID);		return false;	}	mcb.SetPSPSeg(MCB_FREE);//	DOS_CompressMemory();	return true;}

bool DOS_GetFreeDiskSpace(Bit8u drive,Bit16u * bytes,Bit8u * sectors,Bit16u * clusters,Bit16u * free) {    if (drive==0) drive=DOS_GetDefaultDrive();    else drive--;    if ((drive>=DOS_DRIVES) || (!Drives[drive])) {        DOS_SetError(DOSERR_INVALID_DRIVE);        return false;    }    return Drives[drive]->AllocationInfo(bytes,sectors,clusters,free);}

bool DOS_GetFileDate(Bit16u entry, Bit16u* otime, Bit16u* odate) {    Bit32u handle=RealHandle(entry);    if (handle>=DOS_FILES) {        DOS_SetError(DOSERR_INVALID_HANDLE);        return false;    };    if (!Files[handle] || !Files[handle]->IsOpen()) {        DOS_SetError(DOSERR_INVALID_HANDLE);        return false;    };    if (!Files[handle]->UpdateDateTimeFromHost()) {        DOS_SetError(DOSERR_INVALID_HANDLE);        return false;    }    *otime = Files[handle]->time;    *odate = Files[handle]->date;    return true;}

bool physfscdromDrive::FileOpen(DOS_File * * file,const char * name,Bit32u flags){	if ((flags&0xf)==OPEN_READWRITE) {		flags &= ~OPEN_READWRITE;	} else if ((flags&0xf)==OPEN_WRITE) {		DOS_SetError(DOSERR_ACCESS_DENIED);		return false;	}	return physfsDrive::FileOpen(file,name,flags);};

bool DOS_UnlinkFile(char const * const name) {	char fullname[DOS_PATHLENGTH];Bit8u drive;	if (!DOS_MakeName(name,fullname,&drive)) return false;	if(Drives[drive]->FileUnlink(fullname)){		return true;	} else {		DOS_SetError(DOSERR_FILE_NOT_FOUND);		return false;	}}

bool DOS_FlushFile(Bit16u entry)	{	Bit32u handle = RealHandle(entry);	if (handle >= DOS_FILES || !Files[handle])		{		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;		}	return true;	}

bool DOS_SeekFile(Bit16u entry, Bit32u* pos, Bit32u type)	{	Bit32u handle = RealHandle(entry);	if (handle >= DOS_FILES || !Files[handle])		{		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;		}	return Files[handle]->Seek(pos, type);	}

bool DOS_ReadFile(Bit16u entry, Bit8u* data, Bit16u* amount)	{	Bit32u handle = RealHandle(entry);	if (handle >= DOS_FILES || !Files[handle])		{		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;		}	return Files[handle]->Read(data, amount);}

bool DOS_GetCurrentDir(Bit8u drive,char * const buffer) {    if (drive==0) drive=DOS_GetDefaultDrive();    else drive--;    if ((drive>=DOS_DRIVES) || (!Drives[drive])) {        DOS_SetError(DOSERR_INVALID_DRIVE);        return false;    }    strcpy(buffer,Drives[drive]->curdir);    return true;}

bool DOS_LockFile(Bit16u entry, Bit8u mode, Bit32u pos, Bit32u size)	{	Bit32u handle = RealHandle(entry);	if (handle >= DOS_FILES || !Files[handle])		{		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;		}	return Files[handle]->LockFile(mode, pos, size);	}

bool DOS_GetFileAttr(char const * const name,Bit16u * attr) {	char fullname[DOS_PATHLENGTH];Bit8u drive;	if (!DOS_MakeName(name,fullname,&drive)) return false;	if (Drives[drive]->GetFileAttr(fullname,attr)) {		return true;	} else {		DOS_SetError(DOSERR_FILE_NOT_FOUND);		return false;	}}

bool localDrive::FindNext(DOS_DTA & dta) {	char * dir_ent;	struct stat stat_block;	char full_name[CROSS_LEN];	char dir_entcopy[CROSS_LEN];	Bit8u srch_attr;char srch_pattern[DOS_NAMELENGTH_ASCII];	Bit8u find_attr;	dta.GetSearchParams(srch_attr,srch_pattern);	Bit16u id = dta.GetDirID();again:	if (!dirCache.FindNext(id,dir_ent)) {		DOS_SetError(DOSERR_NO_MORE_FILES);		return false;	}	if(!WildFileCmp(dir_ent,srch_pattern)) goto again;	strcpy(full_name,srchInfo[id].srch_dir);	strcat(full_name,dir_ent);		//GetExpandName might indirectly destroy dir_ent (by caching in a new directory 	//and due to its design dir_ent might be lost.)	//Copying dir_ent first	strcpy(dir_entcopy,dir_ent);	if (stat(dirCache.GetExpandName(full_name),&stat_block)!=0) { 		goto again;//No symlinks and such	}		if(stat_block.st_mode & S_IFDIR) find_attr=DOS_ATTR_DIRECTORY;	else find_attr=DOS_ATTR_ARCHIVE; 	if (~srch_attr & find_attr & (DOS_ATTR_DIRECTORY | DOS_ATTR_HIDDEN | DOS_ATTR_SYSTEM)) goto again;		/*file is okay, setup everything to be copied in DTA Block */	char find_name[DOS_NAMELENGTH_ASCII];Bit16u find_date,find_time;Bit32u find_size;	if(strlen(dir_entcopy)<DOS_NAMELENGTH_ASCII){		strcpy(find_name,dir_entcopy);		upcase(find_name);	} 	find_size=(Bit32u) stat_block.st_size;	struct tm *time;	if((time=localtime(&stat_block.st_mtime))!=0){		find_date=DOS_PackDate((Bit16u)(time->tm_year+1900),(Bit16u)(time->tm_mon+1),(Bit16u)time->tm_mday);		find_time=DOS_PackTime((Bit16u)time->tm_hour,(Bit16u)time->tm_min,(Bit16u)time->tm_sec);	} else {		find_time=6; 		find_date=4;	}	dta.SetResult(find_name,find_size,find_date,find_time,find_attr);	return true;}

bool cdromDrive::FileOpen(DOS_File * * file,char * name,Bit32u flags) {	if ((flags&0xf)==OPEN_READWRITE) {		flags &= ~OPEN_READWRITE;	} else if ((flags&0xf)==OPEN_WRITE) {		DOS_SetError(DOSERR_ACCESS_DENIED);		return false;	}	bool retcode = localDrive::FileOpen(file,name,flags);	if(retcode) (dynamic_cast<localFile*>(*file))->FlagReadOnlyMedium();	return retcode;}

bool DOS_CreateFile(char const* name, Bit16u attributes, Bit16u* entry)	{	if (DOS_FindDevice(name) != DOS_DEVICES)											// Creating a device is the same as opening it		return DOS_OpenFile(name, OPEN_READWRITE, entry);	char fullname[DOS_PATHLENGTH];	Bit8u drive;	if (!DOS_MakeName(name, fullname, &drive))		return false;	Bit8u handle;	for (handle = 0; handle < DOS_FILES; handle++)										// Check for a free file handle		if (!Files[handle])			break;	if (handle == DOS_FILES)		{		DOS_SetError(DOSERR_TOO_MANY_OPEN_FILES);		return false;		}	DOS_PSP psp(dos.psp());																// We have a position in the main table, now find one in the psp table	*entry = psp.FindFreeFileEntry();	if (*entry == 0xff)		{		DOS_SetError(DOSERR_TOO_MANY_OPEN_FILES);		return false;		}	if (attributes&DOS_ATTR_DIRECTORY)													// Don't allow directories to be created		{		DOS_SetError(DOSERR_ACCESS_DENIED);		return false;		}	if (Drives[drive]->FileCreate(&Files[handle], fullname, attributes))		{ 		Files[handle]->SetDrive(drive);		Files[handle]->AddRef();		psp.SetFileHandle(*entry, handle);		return true;		}	DOS_SetError(PathExists(name) ? DOSERR_FILE_ALREADY_EXISTS : DOSERR_PATH_NOT_FOUND);	return false;	}

bool DOS_ReadFile(Bit16u entry,Bit8u * data,Bit16u * amount) {	Bit32u handle=RealHandle(entry);	if (handle>=DOS_FILES) {		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;	};	if (!Files[handle] || !Files[handle]->IsOpen()) {		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;	};/*	if ((Files[handle]->flags & 0x0f) == OPEN_WRITE)) {		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;	}*/	Bit16u toread=*amount;	bool ret=Files[handle]->Read(data,&toread);	*amount=toread;	return ret;}

bool DOS_WriteFile(Bit16u entry,Bit8u * data,Bit16u * amount,bool fcb) {    Bit32u handle = fcb?entry:RealHandle(entry);    if (handle>=DOS_FILES) {        DOS_SetError(DOSERR_INVALID_HANDLE);        return false;    };    if (!Files[handle] || !Files[handle]->IsOpen()) {        DOS_SetError(DOSERR_INVALID_HANDLE);        return false;    };    /*    	if ((Files[handle]->flags & 0x0f) == OPEN_READ)) {    		DOS_SetError(DOSERR_INVALID_HANDLE);    		return false;    	}    */    Bit16u towrite=*amount;    bool ret=Files[handle]->Write(data,&towrite);    *amount=towrite;    return ret;}

bool DOS_FindNext(void) {    DOS_DTA dta(dos.dta());    Bit8u i = dta.GetSearchDrive();    if(i >= DOS_DRIVES || !Drives[i]) {        /* Corrupt search. */        LOG(LOG_FILES,LOG_ERROR)("Corrupt search!!!!");        DOS_SetError(DOSERR_NO_MORE_FILES);        return false;    }    if (Drives[i]->FindNext(dta)) return true;    return false;}

bool DOS_ForceDuplicateEntry(Bit16u entry, Bit16u newentry)	{	if (entry == newentry)		{		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;		}	Bit8u orig = RealHandle(entry);	if (orig >= DOS_FILES || !Files[orig])		{		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;		}	Bit8u newone = RealHandle(newentry);	if (newone < DOS_FILES && Files[newone])		DOS_CloseFile(newentry);	DOS_PSP psp(dos.psp());	Files[orig]->AddRef();	psp.SetFileHandle(newentry, orig);	return true;	}

bool DOS_CloseFile(Bit16u entry) {	Bit32u handle=RealHandle(entry);	if (handle>=DOS_FILES) {		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;	};	if (!Files[handle]) {		DOS_SetError(DOSERR_INVALID_HANDLE);		return false;	};	if (Files[handle]->IsOpen()) {		Files[handle]->Close();	}	DOS_PSP psp(dos.psp());	psp.SetFileHandle(entry,0xff);	if (Files[handle]->RemoveRef()<=0) {		delete Files[handle];		Files[handle]=0;	}	return true;}

bool DOS_ChangeDir(char const * const dir) {	Bit8u drive;char fulldir[DOS_PATHLENGTH];	if (!DOS_MakeName(dir,fulldir,&drive)) return false;		if (Drives[drive]->TestDir(fulldir)) {		strcpy(Drives[drive]->curdir,fulldir);		return true;	} else {		DOS_SetError(DOSERR_PATH_NOT_FOUND);	}	return false;}

bool physfsFile::Read(Bit8u * data,Bit16u * size) {	if ((this->flags & 0xf) == OPEN_WRITE) {        // check if file opened in write-only mode		DOS_SetError(DOSERR_ACCESS_DENIED);		return false;	}	if (last_action==WRITE) prepareRead();	last_action=READ;	PHYSFS_sint64 mysize = PHYSFS_read(fhandle,data,1,(PHYSFS_uint32)*size);	//LOG_MSG("Read %i bytes (wanted %i) at %i of %s (%s)",(int)mysize,(int)*size,(int)PHYSFS_tell(fhandle),name,PHYSFS_getLastError());	*size = (Bit16u)mysize;	return true;}

bool DOS_RemoveDir(char const * const dir)	{	/* We need to do the test before the removal as can not rely on	 * the host to forbid removal of the current directory.	 * We never change directory. Everything happens in the drives.	 */	Bit8u drive;	const char *testdir = dir;	if (*testdir && testdir[1] == ':')		{		drive = (*testdir | 0x20)-'a';		if (drive >= DOS_DRIVES || !Drives[drive])			{			DOS_SetError(DOSERR_INVALID_DRIVE);			return false;			}		testdir += 2;		}	size_t len = strlen(testdir);	char fulldir[DOS_PATHLENGTH];	if (!len || !DOS_MakeName(dir, fulldir, &drive) || (*fulldir && testdir[len-1] == '//'))		{		DOS_SetError(DOSERR_PATH_NOT_FOUND);		return false;		}	if (!Drives[drive]->TestDir(fulldir))											// Check if exists		{		DOS_SetError(DOSERR_PATH_NOT_FOUND);		return false;		}	if (strcmp(Drives[drive]->curdir, fulldir) == 0)								// Test if it's current directory		{		DOS_SetError(DOSERR_REMOVE_CURRENT_DIRECTORY);		return false;		}	if (Drives[drive]->RemoveDir(fulldir))		return true;	DOS_SetError(DOSERR_ACCESS_DENIED);												// Failed. We know it exists and it's not the current dir assume non empty	return false;	}

bool fatFile::Read(Bit8u * data, Bit16u *size) {	if ((this->flags & 0xf) == OPEN_WRITE) {	// check if file opened in write-only mode		DOS_SetError(DOSERR_ACCESS_DENIED);		return false;	}	Bit16u sizedec, sizecount;	if(seekpos >= filelength) {		*size = 0;		return true;	}	if (!loadedSector) {		currentSector = myDrive->getAbsoluteSectFromBytePos(firstCluster, seekpos);		if(currentSector == 0) {			/* EOC reached before EOF */			*size = 0;			loadedSector = false;			return true;		}		curSectOff = 0;		myDrive->loadedDisk->Read_AbsoluteSector(currentSector, sectorBuffer);		loadedSector = true;	}	sizedec = *size;	sizecount = 0;	while(sizedec != 0) {		if(seekpos >= filelength) {			*size = sizecount;			return true; 		}		data[sizecount++] = sectorBuffer[curSectOff++];		seekpos++;		if(curSectOff >= myDrive->getSectorSize()) {			currentSector = myDrive->getAbsoluteSectFromBytePos(firstCluster, seekpos);			if(currentSector == 0) {				/* EOC reached before EOF */				//LOG_MSG("EOC reached before EOF, seekpos %d, filelen %d", seekpos, filelength);				*size = sizecount;				loadedSector = false;				return true;			}			curSectOff = 0;			myDrive->loadedDisk->Read_AbsoluteSector(currentSector, sectorBuffer);			loadedSector = true;			//LOG_MSG("Reading absolute sector at %d for seekpos %d", currentSector, seekpos);		}		--sizedec;	}	*size =sizecount;	return true;}

bool DOS_OpenFileExtended(char const* name, Bit16u flags, Bit16u createAttr, Bit16u action, Bit16u* entry, Bit16u* status)	{	// FIXME: Not yet supported : Bit 13 of flags (int 0x24 on critical error)	Bit16u result = 0;	if (action == 0 || action&0xffec)		{		DOS_SetError(DOSERR_FUNCTION_NUMBER_INVALID);		return false;		}	if (DOS_OpenFile(name, (Bit8u)(flags&0xff), entry))								// File already exists		{		switch (action & 0x0f)			{		case 0:																		// Failed			DOS_CloseFile(*entry);			DOS_SetError(DOSERR_FILE_ALREADY_EXISTS);			return false;		case 1:																		// File open (already done)			result = 1;			break;		case 2:																		// Replace			DOS_CloseFile(*entry);			if (!DOS_CreateFile(name, createAttr, entry))				return false;			result = 3;			break;			}		}	else																			// File doesn't exist		{		if ((action & 0xf0) == 0)			return false;															// Uses error code from failed open		if (!DOS_CreateFile(name, createAttr, entry))								// Create File			return false;															// Uses error code from failed create		result = 2;		}	*status = result;																// Success	return true;	}

bool DOS_GetAllocationInfo(Bit8u drive,Bit16u * _bytes_sector,Bit8u * _sectors_cluster,Bit16u * _total_clusters) {    if (!drive) drive =  DOS_GetDefaultDrive();    else drive--;    if (drive >= DOS_DRIVES || !Drives[drive]) {        DOS_SetError(DOSERR_INVALID_DRIVE);        return false;    }    Bit16u _free_clusters;    Drives[drive]->AllocationInfo(_bytes_sector,_sectors_cluster,_total_clusters,&_free_clusters);    SegSet16(ds,RealSeg(dos.tables.mediaid));    reg_bx=RealOff(dos.tables.mediaid+drive*2);    return true;}

bool localDrive::FileOpen(DOS_File * * file,char * name,Bit32u flags) {	const char* type;	switch (flags&0xf) {	case OPEN_READ:        type = "rb" ; break;	case OPEN_WRITE:       type = "rb+"; break;	case OPEN_READWRITE:   type = "rb+"; break;	case OPEN_READ_NO_MOD: type = "rb" ; break; //No modification of dates. LORD4.07 uses this	default:		DOS_SetError(DOSERR_ACCESS_CODE_INVALID);		return false;	}	char newname[CROSS_LEN];	strcpy(newname,basedir);	strcat(newname,name);	CROSS_FILENAME(newname);	dirCache.ExpandName(newname);	//Flush the buffer of handles for the same file. (Betrayal in Antara)	Bit8u i,drive=DOS_DRIVES;	localFile *lfp;	for (i=0;i<DOS_DRIVES;i++) {		if (Drives[i]==this) {			drive=i;			break;		}	}	for (i=0;i<DOS_FILES;i++) {		if (Files[i] && Files[i]->IsOpen() && Files[i]->GetDrive()==drive && Files[i]->IsName(name)) {			lfp=dynamic_cast<localFile*>(Files[i]);			if (lfp) lfp->Flush();		}	}	FILE * hand=fopen(newname,type);//	Bit32u err=errno;	if (!hand) { 		if((flags&0xf) != OPEN_READ) {			FILE * hmm=fopen(newname,"rb");			if (hmm) {				fclose(hmm);				LOG_MSG("Warning: file %s exists and failed to open in write mode./nPlease Remove write-protection",newname);			}		}		return false;	}	*file=new localFile(name,hand);	(*file)->flags=flags;  //for the inheritance flag and maybe check for others.//	(*file)->SetFileName(newname);	return true;}

bool DOS_SetFileAttr(char const * const name,Bit16u /*attr*/) // this function does not change the file attributs// it just does some tests if file is available // returns false when using on cdrom (stonekeep){	Bit16u attrTemp;	char fullname[DOS_PATHLENGTH];Bit8u drive;	if (!DOS_MakeName(name,fullname,&drive)) return false;		if (strncmp(Drives[drive]->GetInfo(),"CDRom ",6)==0 || strncmp(Drives[drive]->GetInfo(),"isoDrive ",9)==0) {		DOS_SetError(DOSERR_ACCESS_DENIED);		return false;	}	return Drives[drive]->GetFileAttr(fullname,&attrTemp);}

bool DOS_ChangeDir(char const * const dir) {	Bit8u drive;char fulldir[DOS_PATHLENGTH];	const char * testdir=dir;	if (strlen(testdir) && testdir[1]==':') testdir+=2;	size_t len=strlen(testdir);	if (!len) {		DOS_SetError(DOSERR_PATH_NOT_FOUND);		return false;	}	if (!DOS_MakeName(dir,fulldir,&drive)) return false;	if (strlen(fulldir) && testdir[len-1]=='//') {		DOS_SetError(DOSERR_PATH_NOT_FOUND);		return false;	}		if (Drives[drive]->TestDir(fulldir)) {		strcpy(Drives[drive]->curdir,fulldir);		return true;	} else {		DOS_SetError(DOSERR_PATH_NOT_FOUND);	}	return false;}