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

int impl_fuse_context::get_file_information(    LPCWSTR file_name, LPBY_HANDLE_FILE_INFORMATION handle_file_information,    PDOKAN_FILE_INFO dokan_file_info) {  std::string fname = unixify(wchar_to_utf8_cstr(file_name));  if (!ops_.getattr)    return -EINVAL;  struct FUSE_STAT st = {0};  CHECKED(ops_.getattr(fname.c_str(), &st));  if (S_ISLNK(st.st_mode)) {    std::string resolved;    CHECKED(resolve_symlink(fname, &resolved));    CHECKED(ops_.getattr(resolved.c_str(), &st));  }  handle_file_information->nNumberOfLinks = st.st_nlink;  if ((st.st_mode & S_IFDIR) == S_IFDIR)    dokan_file_info->IsDirectory = TRUE;  convertStatlikeBuf(&st, fname, handle_file_information);  uint32_t attrs = 0xFFFFFFFFu;  if (ops_.win_get_attributes)    attrs = ops_.win_get_attributes(fname.c_str());  if (attrs != 0xFFFFFFFFu)    handle_file_information->dwFileAttributes = attrs;  return 0;}

int impl_fuse_context::walk_directory(void *buf, const char *name,									  const struct stat *stbuf, FUSE_OFF_T off){	walk_data *wd=(walk_data*)buf;	WIN32_FIND_DATAW find_data={0};	utf8_to_wchar_buf(name,find_data.cFileName,MAX_PATH);	GetShortPathNameW(find_data.cFileName,find_data.cAlternateFileName,MAX_PATH);	struct FUSE_STAT stat={0};	if (stbuf!=NULL)		stat=*stbuf;	else	{		//No stat buffer - use 'getattr'.		//TODO: fill directory params here!!!		if (strcmp(name,".")==0 || strcmp(name,"..")==0) //Special entries			stat.st_mode|=S_IFDIR;		else			CHECKED(wd->ctx->ops_.getattr((wd->dirname+name).c_str(),&stat));	}	if (S_ISLNK(stat.st_mode))	{		std::string resolved;		CHECKED(wd->ctx->resolve_symlink(wd->dirname+name,&resolved));		CHECKED(wd->ctx->ops_.getattr(resolved.c_str(),&stat));	}	convertStatlikeBuf(&stat,name,&find_data);	return wd->delegate(&find_data,wd->DokanFileInfo);}

win_error impl_fuse_context::create_file(LPCWSTR file_name, DWORD access_mode, 								   DWORD share_mode, DWORD creation_disposition, 								   DWORD flags_and_attributes, 								   PDOKAN_FILE_INFO dokan_file_info){	std::string fname=unixify(wchar_to_utf8_cstr(file_name));	dokan_file_info->Context=0;	if (!ops_.getattr)		return -EINVAL;	struct FUSE_STAT stbuf={0};	//Check if the target file/directory exists	if (ops_.getattr(fname.c_str(),&stbuf)<0)	{		//Nope.				if (dokan_file_info->IsDirectory) 			return -EINVAL; //We can't create directories using CreateFile		return do_create_file(file_name, creation_disposition, share_mode, access_mode,			dokan_file_info);	} else	{				if (S_ISLNK(stbuf.st_mode))		{			//Get link's target			CHECKED(resolve_symlink(fname,&fname));			CHECKED(ops_.getattr(fname.c_str(),&stbuf));		}		if ((stbuf.st_mode&S_IFDIR)==S_IFDIR)		{			//Existing directory			//TODO: add access control			dokan_file_info->IsDirectory=TRUE;			return do_open_dir(file_name,dokan_file_info);		} else		{			//Existing file			//Check if we'll be able to truncate or delete the opened file			//TODO: race condition here?			if (creation_disposition==CREATE_ALWAYS)			{				if (!ops_.unlink) return -EINVAL;				CHECKED(ops_.unlink(fname.c_str())); //Delete file				//And create it!				return do_create_file(file_name,creation_disposition, share_mode,					access_mode,dokan_file_info);			} else if (creation_disposition==TRUNCATE_EXISTING)			{				if (!ops_.truncate) return -EINVAL;				CHECKED(ops_.truncate(fname.c_str(),0));			} else if (creation_disposition==CREATE_NEW)			{				return win_error(ERROR_FILE_EXISTS, true);			}			return do_open_file(file_name, share_mode, access_mode, dokan_file_info);		}	}}

int VM::New(VMStartParams &params, Box<VM> &result){	int status__;	{		if (!vmKey.IsValid())			CHECKED_MEM(vmKey.Alloc());		Box<VM> vm(new(std::nothrow) VM(params));		CHECKED_MEM(vm.get());		// Most things rely on static strings, so initialize them first.		CHECKED_MEM(vm->strings = StaticStrings::New());		CHECKED_MEM(vm->mainThread = Thread::New(vm.get()));		CHECKED_MEM(vm->gc = GC::New(vm.get()));		CHECKED_MEM(vm->standardTypeCollection = StandardTypeCollection::New(vm.get()));		CHECKED_MEM(vm->modules = ModulePool::New(10));		CHECKED_MEM(vm->refSignatures = Box<RefSignaturePool>(new(std::nothrow) RefSignaturePool()));		CHECKED(vm->LoadModules(params));		CHECKED(vm->InitArgs(params.argc, params.argv));		result = std::move(vm);	}	status__ = OVUM_SUCCESS;retStatus__:	return status__;}

int impl_fuse_context::open_directory(LPCWSTR file_name, 									  PDOKAN_FILE_INFO dokan_file_info){	std::string fname=unixify(wchar_to_utf8_cstr(file_name));		if (ops_.opendir)		return do_open_dir(file_name,dokan_file_info);	//We don't have opendir(), so the most we can do is make sure	//that the target is indeed a directory	struct FUSE_STAT st={0};	CHECKED(ops_.getattr(fname.c_str(),&st));	if (S_ISLNK(st.st_mode))	{		std::string resolved;		CHECKED(resolve_symlink(fname,&resolved));			CHECKED(ops_.getattr(resolved.c_str(),&st));	}	//Not a directory	if ((st.st_mode&S_IFDIR)!=S_IFDIR)		return -ENOTDIR;		dokan_file_info->Context=(ULONG64)NULL; //Do not want to attach anything	return 0; //Use readdir here?}

int impl_fuse_context::do_create_file(LPCWSTR FileName, DWORD Disposition, DWORD share_mode, DWORD Flags,									PDOKAN_FILE_INFO DokanFileInfo){	std::string fname=unixify(wchar_to_utf8_cstr(FileName));	//Create file?	if (Disposition!=CREATE_NEW && Disposition!=CREATE_ALWAYS && Disposition!=OPEN_ALWAYS)				return -ENOENT; //No, we're trying to open an existing file!	if (!ops_.create)	{		//Use mknod+open.		if (!ops_.mknod || !ops_.open) return -EINVAL;		CHECKED(ops_.mknod(fname.c_str(),filemask_,0));		return do_open_file(FileName, share_mode, Flags, DokanFileInfo);	}	std::auto_ptr<impl_file_handle> file;	CHECKED(file_locks.get_file(fname,false,Flags,share_mode,file));	fuse_file_info finfo={0};	finfo.flags=O_CREAT | O_EXCL | convert_flags(Flags); //TODO: these flags should be OK for new files?			CHECKED(ops_.create(fname.c_str(),filemask_,&finfo));	DokanFileInfo->Context=reinterpret_cast<ULONG64>(file.release());	return 0;}

int impl_fuse_context::check_and_resolve(std::string *name) {  if (!ops_.getattr)    return -EINVAL;  struct FUSE_STAT stat = {0};  CHECKED(ops_.getattr(name->c_str(), &stat));  if (S_ISLNK(stat.st_mode))    CHECKED(resolve_symlink(*name, name));  return 0;}

	~mmio_stream_raii() {				data_info.dwFlags |= MMIO_DIRTY;				CHECKED(mmioSetInfo( mmio, &data_info, 0 ));			CHECKED(mmioAscend( mmio, &data_chunk, 0 ));		CHECKED(mmioAscend( mmio, &WAVE_chunk, 0 ));		CHECKED(mmioClose( mmio, 0 ));		mmio = NULL;	}

int impl_fuse_context::walk_directory(void *buf, const char *name, 									  const struct FUSE_STAT *stbuf, FUSE_OFF_T off){	walk_data *wd=(walk_data*)buf;	WIN32_FIND_DATAW find_data={0};		utf8_to_wchar_buf(name,find_data.cFileName,MAX_PATH);	// fix name if wrong encoding	if (!find_data.cFileName[0]) {		struct FUSE_STAT stbuf={0};		utf8_to_wchar_buf_old(name,find_data.cFileName,MAX_PATH);		std::string new_name = wchar_to_utf8_cstr(find_data.cFileName);		if (wd->ctx->ops_.getattr && wd->ctx->ops_.rename && new_name.length() && wd->ctx->ops_.getattr(new_name.c_str(),&stbuf) == -ENOENT)			wd->ctx->ops_.rename(name, new_name.c_str());	}	memset(find_data.cAlternateFileName, 0, sizeof(find_data.cAlternateFileName));	struct FUSE_STAT stat={0};	if (stbuf!=NULL)		stat=*stbuf;			else	{		//No stat buffer - use 'getattr'.		//TODO: fill directory params here!!!		if (strcmp(name,".")==0 || strcmp(name,"..")==0) //Special entries			stat.st_mode|=S_IFDIR;		else			CHECKED(wd->ctx->ops_.getattr((wd->dirname+name).c_str(),&stat));	}	if (S_ISLNK(stat.st_mode))	{		std::string resolved;		CHECKED(wd->ctx->resolve_symlink(wd->dirname+name,&resolved));				CHECKED(wd->ctx->ops_.getattr(resolved.c_str(),&stat));			}		convertStatlikeBuf(&stat,name,&find_data);	uint32_t attrs = 0xFFFFFFFFu;	if (wd->ctx->ops_.win_get_attributes)		attrs = wd->ctx->ops_.win_get_attributes((wd->dirname+name).c_str());	if (attrs != 0xFFFFFFFFu)		find_data.dwFileAttributes = attrs;		return wd->delegate(&find_data,wd->DokanFileInfo);}

int impl_fuse_context::move_file(LPCWSTR file_name, LPCWSTR new_file_name,			  BOOL replace_existing, PDOKAN_FILE_INFO dokan_file_info){	if (!ops_.rename || !ops_.getattr) return -EINVAL;	std::string name=unixify(wchar_to_utf8_cstr(file_name));	std::string new_name=unixify(wchar_to_utf8_cstr(new_file_name));	struct FUSE_STAT stbuf={0};	if (ops_.getattr(new_name.c_str(),&stbuf)!=-ENOENT)	{		//Cannot delete directory		if ((stbuf.st_mode&S_IFDIR)==0 && ops_.unlink)        {            if (replace_existing)            {                CHECKED(ops_.unlink(new_name.c_str()));            }            else            {                return -EEXIST;            }		}	}	return ops_.rename(name.c_str(),new_name.c_str());}

int impl_fuse_context::unlock_file(LPCWSTR file_name, LONGLONG byte_offset,                                   LONGLONG length,                                   PDOKAN_FILE_INFO dokan_file_info) {  impl_file_handle *hndl =      reinterpret_cast<impl_file_handle *>(dokan_file_info->Context);  if (!hndl)    return -EINVAL;  if (hndl->is_dir())    return -EACCES;  FUSE_OFF_T off;  CHECKED(cast_from_longlong(byte_offset, &off));  if (ops_.lock) {    fuse_file_info finfo(hndl->make_finfo());    struct flock lock;    lock.l_type = F_UNLCK;    lock.l_whence = SEEK_SET;    lock.l_start = off;    lock.l_len = length;    return ops_.lock(hndl->get_name().c_str(), &finfo, F_SETLK, &lock);  }  return hndl->unlock(byte_offset, length);}

void DesktopDuplication::init(){	IDXGIFactory1* dxgiFactory = nullptr;	CHECKED(hr, CreateDXGIFactory1(__uuidof(IDXGIFactory1), reinterpret_cast<void**>(&dxgiFactory)));	IDXGIAdapter1* dxgiAdapter = nullptr;	CHECKED(hr, dxgiFactory->EnumAdapters1(adapter, &dxgiAdapter));	dxgiFactory->Release();	CHECKED(hr, D3D11CreateDevice(dxgiAdapter,		D3D_DRIVER_TYPE_UNKNOWN,		NULL,		NULL,		NULL,		NULL,		D3D11_SDK_VERSION,		&d3dDevice,		NULL,		&d3dContext));	IDXGIOutput* dxgiOutput = nullptr;	CHECKED(hr, dxgiAdapter->EnumOutputs(output, &dxgiOutput));	dxgiAdapter->Release();	IDXGIOutput1* dxgiOutput1 = nullptr;	CHECKED(hr, dxgiOutput->QueryInterface(__uuidof(dxgiOutput1), reinterpret_cast<void**>(&dxgiOutput1)));	dxgiOutput->Release();	IDXGIDevice* dxgiDevice = nullptr;	CHECKED(hr, d3dDevice->QueryInterface(__uuidof(IDXGIDevice), reinterpret_cast<void**>(&dxgiDevice)));	CHECKED(hr, dxgiOutput1->DuplicateOutput(dxgiDevice, &outputDuplication));	dxgiOutput1->Release();	dxgiDevice->Release();}

	mmio_stream_raii( const std::string & filename, const commandlineflags & flags_ ) : flags(flags_), mmio(NULL) {		ZeroMemory( &waveformatex, sizeof( WAVEFORMATEX ) );		waveformatex.cbSize = 0;		waveformatex.wFormatTag = flags.use_float ? WAVE_FORMAT_IEEE_FLOAT : WAVE_FORMAT_PCM;		waveformatex.nChannels = flags.channels;		waveformatex.nSamplesPerSec = flags.samplerate;		waveformatex.wBitsPerSample = flags.use_float ? 32 : 16;		waveformatex.nBlockAlign = flags.channels * ( waveformatex.wBitsPerSample / 8 );		waveformatex.nAvgBytesPerSec = waveformatex.nSamplesPerSec * waveformatex.nBlockAlign;		#if defined(WIN32) && defined(UNICODE)			wchar_t * tmp = wcsdup( utf8_to_wstring( filename ).c_str() );			mmio = mmioOpen( tmp, NULL, MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_CREATE );			free( tmp );			tmp = 0;		#else			char * tmp = strdup( filename.c_str() );			mmio = mmioOpen( tmp, NULL, MMIO_ALLOCBUF | MMIO_READWRITE | MMIO_CREATE );			free( tmp );			tmp = 0;		#endif				ZeroMemory( &WAVE_chunk, sizeof( MMCKINFO ) );		WAVE_chunk.fccType = mmioFOURCC('W', 'A', 'V', 'E');		CHECKED(mmioCreateChunk( mmio, &WAVE_chunk, MMIO_CREATERIFF ));			ZeroMemory( &fmt__chunk, sizeof( MMCKINFO ) );			fmt__chunk.ckid = mmioFOURCC('f', 'm', 't', ' ');			fmt__chunk.cksize = sizeof( WAVEFORMATEX );			CHECKED(mmioCreateChunk( mmio, &fmt__chunk, 0 ));				mmioWrite( mmio, (const char*)&waveformatex, sizeof( WAVEFORMATEX ) );			CHECKED(mmioAscend( mmio, &fmt__chunk, 0 ));			ZeroMemory( &data_chunk, sizeof( MMCKINFO ) );			data_chunk.ckid = mmioFOURCC('d', 'a', 't', 'a');			data_chunk.cksize = 0;			CHECKED(mmioCreateChunk( mmio, &data_chunk, 0 ));				ZeroMemory( &data_info, sizeof( MMIOINFO ) );				CHECKED(mmioGetInfo( mmio, &data_info, 0 ));	}

ABoolpath_exists( const char*  path ){    int  ret;    if (path == NULL)        return 0;    CHECKED(ret, access(path, F_OK));    return (ret == 0) || (errno != ENOENT);}

ABoolpath_can_exec( const char* path ){    int  ret;    if (path == NULL)        return 0;    CHECKED(ret, access(path, X_OK));    return (ret == 0);}

AVES_API BEGIN_NATIVE_FUNCTION(aves_Utf16Encoding_getByteCount){	// getByteCount(str)	CHECKED(StringFromValue(thread, args + 1));	Utf16Encoding *encoding = THISV.Get<Utf16Encoding>();	Utf16Encoder enc(encoding->bigEndian);	ssize_t byteCount = enc.GetByteCount(thread, args[1].v.string, true);	VM_PushInt(thread, byteCount);}

	void write( const std::vector<std::int16_t*> buffers, std::size_t frames ) {		for ( std::size_t frame = 0; frame < frames; frame++ ) {			for ( std::size_t channel = 0; channel < buffers.size(); channel++ ) {				if ( data_info.pchEndWrite - data_info.pchNext < static_cast<long>( sizeof( std::int16_t ) ) ) {					data_info.dwFlags |= MMIO_DIRTY;					CHECKED(mmioAdvance( mmio, &data_info, MMIO_WRITE ));				}				std::memcpy( data_info.pchNext, &( buffers[channel][frame] ), sizeof( std::int16_t ) );				data_info.pchNext += sizeof( std::int16_t );			}		}	}

/* try to make a directory. returns 0 on success, -1 on failure * (error code in errno) */APosixStatuspath_mkdir( const char*  path, int  mode ){#ifdef _WIN32    (void)mode;    return _mkdir(path);#else    int  ret;    CHECKED(ret, mkdir(path, mode));    return ret;#endif}

/* checks that a path points to a directory */ABoolpath_is_dir( const char*  path ){    int          ret;    struct stat  st;    if (path == NULL)        return 0;    CHECKED(ret, stat(path, &st));    if (ret < 0)        return 0;    return S_ISDIR(st.st_mode);}

ID3D11Texture2D* DesktopDuplication::copyToStaging(ID3D11Texture2D* tex){	D3D11_TEXTURE2D_DESC texDesc;	tex->GetDesc(&texDesc);	stagingTexDesc = getStagingTexDesc(texDesc);	ID3D11Texture2D* stagingTex;	CHECKED(hr, d3dDevice->CreateTexture2D(&stagingTexDesc, nullptr, &stagingTex));	d3dContext->CopyResource(stagingTex, tex);	return stagingTex;}