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

bool CEGLWrapper::ChooseConfig(EGLDisplay display, EGLint *configAttrs, EGLConfig *config){  EGLint     configCount = 0;  EGLConfig* configList = NULL;  // Find out how many configurations suit our needs  EGLBoolean eglStatus = eglChooseConfig(display, configAttrs, NULL, 0, &configCount);  CheckError();  if (!eglStatus || !configCount)  {    CLog::Log(LOGERROR, "EGL failed to return any matching configurations: %i", configCount);    return false;  }  // Allocate room for the list of matching configurations  configList = (EGLConfig*)malloc(configCount * sizeof(EGLConfig));  if (!configList)  {    CLog::Log(LOGERROR, "EGL failure obtaining configuration list");    return false;  }  // Obtain the configuration list from EGL  eglStatus = eglChooseConfig(display, configAttrs, configList, configCount, &configCount);  CheckError();  if (!eglStatus || !configCount)  {    CLog::Log(LOGERROR, "EGL failed to populate configuration list: %d", eglStatus);    return false;  }  // Select an EGL configuration that matches the native window  *config = configList[0];  free(configList);  return m_result == EGL_SUCCESS;}

int OWStatement::GetInteger( OCINumber* ppoData ){    sb4 nRetVal;    CheckError( OCINumberToInt(        hError,        ppoData,        (uword) sizeof(sb4),        OCI_NUMBER_SIGNED,        (dvoid *) &nRetVal ),        hError );    return nRetVal;}

/*===================================STEAM_BlockForResources  Instruct the STEAM resource preload system to get  the indicated resources and block until all are  obtained.  ***NOTE*** THIS BLOCKS (DUH) SO DON'T USE WANTONLY===================================*/int STEAM_BlockForResources( const char *hintlist ){	int val = TRUE;#if STEAM_SYNCHRONIZED_PRELOADING	{//		val = SteamHintResourceNeed(hintlist, TRUE, &steamError); // Temporary implementation.		val = SteamWaitForResources(hintlist, &steamError);		CheckError(NULL, &steamError);	}#endif	return val;}

bool CEGLWrapper::CreateSurface(EGLDisplay display, EGLConfig config, EGLSurface *surface){    if (!surface || !m_nativeTypes)        return false;    EGLNativeWindowType *nativeWindow=NULL;    if (!m_nativeTypes->GetNativeWindow((XBNativeWindowType**)&nativeWindow))        return false;    *surface = eglCreateWindowSurface(display, config, *nativeWindow, NULL);    CheckError();    return *surface != EGL_NO_SURFACE;}

/*===================================STEAM_ResumeResourcePreloading  Resume STEAM resource preloading===================================*/int STEAM_ResumeResourcePreloading(void){	int val = TRUE;#if STEAM_SYNCHRONIZED_PRELOADING	{		val = SteamResumeCachePreloading(&steamError);		CheckError(NULL, &steamError);	}#endif	return val;}

   int CONetCDF4::getGroup(const CNetCDF4Path & path)   {      int retvalue = this->ncidp;            CNetCDF4Path::const_iterator         it  = path.begin(), end = path.end();      for (;it != end; it++)      {         const std::string & groupid = *it;         CheckError(nc_inq_ncid(retvalue, const_cast<char*>(groupid.c_str()), &retvalue));      }      return (retvalue);   }

static int ArrayGetInt_(lua_State *L, GLuint array, GLenum pname, int boolean)#define ArrayGetInt(L, array, pname) ArrayGetInt_((L), (array), (pname), 0)#define ArrayGetBoolean(L, array, pname) ArrayGetInt_((L), (array), (pname), 1)    {    GLint param;    GLuint index = luaL_checkinteger(L, 3);    glGetVertexArrayIndexediv(array, index, pname, &param);    CheckError(L);    if(boolean)        lua_pushboolean(L, param);    else        lua_pushinteger(L, param);    return 1;    }

int InsertServerPrerequisiteForMessageType(int msgType, vector<string> * v){	char query[200];	char * fixedInsertStr;	unsigned int len;	int holder;	char * cTemp;	MYSQL * conn;	if(WaitForSingleObject(mysqlMutex, INFINITE) != WAIT_OBJECT_0){		printf("InsertServerPrerequisiteForMessageType: Couldn't acquire mutex. Returning/n");		return GENERIC_ERROR;	}	conn = OpenDatabaseConnection(gffServerDBName);	if(conn == NULL){		printf("InsertServerPrerequisiteForMessageType: OpenDatabaseConnection(gffServerDBName) failed/n");		v->clear();		return ReleaseMutexAndReturnError(mysqlMutex, GENERIC_ERROR);	}	//For each host to measure in the vector	for(unsigned int i=0; i < v->size(); i++){		string temp = v->at(i);		cTemp = (char *)temp.c_str();		fixedInsertStr = "INSERT INTO TableVerificationPrerequisiteModules VALUES(NULL,%i,'%s')";		len = sprintf_s(query, 200, fixedInsertStr, msgType, cTemp);		//////////////////////////////////		if(0 != mysql_real_query(conn, query, len)){			holder = CheckError(conn,mysql_errno(conn));						// if error code is 1062, the entry already exists, so it's ok			if(holder != 1062){				CloseDatabaseConnection(conn);				v->clear();				return ReleaseMutexAndReturnError(mysqlMutex, holder);			}		}	}	CloseDatabaseConnection(conn);	v->clear();	//////////////////////////////////	if(!ReleaseMutex(mysqlMutex)){		printf("InsertServerPrerequisiteForMessageType: Couldn't release mutex. Returning/n");		return GENERIC_ERROR;	}	return GENERIC_SUCCESS;}

static int GetEnumOptIndex(lua_State *L, GLenum pname, uint32_t domain) /* index is optional */    {    GLint data;    GLuint index;    if(!lua_isnoneornil(L, 2))        {        index = luaL_checkinteger(L, 2);        glGetIntegeri_v(pname, index, &data);        }    else        glGetIntegerv(pname, &data);    CheckError(L);    return enums_push(L, domain, data);    }

	void Listener::updateListener()	{		update();		if(mParentNode)		{			mPosition = mLastParentPosition;			mDirection = mLastParentOrientation.zAxis();			mUp = mLastParentOrientation.yAxis();		}		alListener3f(AL_POSITION, mPosition.x, mPosition.y, mPosition.z);		CheckError(alGetError(), "Failed to set Position");		mOrientation[0]= -mDirection.x; // Forward.x		mOrientation[1]= -mDirection.y; // Forward.y		mOrientation[2]= -mDirection.z; // Forward.z		mOrientation[3]= mUp.x; // Up.x		mOrientation[4]= mUp.y; // Up.y		mOrientation[5]= mUp.z; // Up.z		alListenerfv(AL_ORIENTATION, mOrientation);		CheckError(alGetError(), "Failed to set Orientation");	}

void AudioChannel::SetVolume(float newVolume){	volume = std::max(newVolume, 0.f);	if (cur_sources.empty())		return;	boost::recursive_mutex::scoped_lock lck(soundMutex);	for (std::map<CSoundSource*, bool>::iterator it = cur_sources.begin(); it != cur_sources.end(); ++it) {		it->first->UpdateVolume();	}	CheckError("AudioChannel::SetVolume");}

void FOpenGLDrv::DrawArrayedPrimitive(GLenum InMode, GLint InStart, GLsizei InCount){	// bind shader program	SetupPendingShaderProgram();	// Set Program Parameters	SetupPendingShaderProgramParameters();	// Bind Vertex Attributes	SetupPendingVertexAttributeArray();	// Setup Texture	SetupPendingTexture();	glDrawArrays(InMode, InStart, InCount);	CheckError(__FILE__, __LINE__);}

GLintLinkProgram(GLint vshader, GLint fshader){    GLint program = glCreateProgram();    glAttachShader(program, vshader);    glAttachShader(program, fshader);    glLinkProgram(program);    // todo return placeholder program instead?    cpAssertHard(CheckError(program, GL_LINK_STATUS, glGetProgramiv, glGetProgramInfoLog), "Error linking shader program");    return program;}

bool CEGLWrapper::InitDisplay(EGLDisplay *display){  if (!display || !m_nativeTypes)    return false;  //nativeDisplay can be (and usually is) NULL. Don't use if(nativeDisplay) as a test!  EGLint status;  EGLNativeDisplayType *nativeDisplay = NULL;  if (!m_nativeTypes->GetNativeDisplay((XBNativeDisplayType**)&nativeDisplay))    return false;  *display = eglGetDisplay(*nativeDisplay);  CheckError();  if (*display == EGL_NO_DISPLAY)  {    CLog::Log(LOGERROR, "EGL failed to obtain display");    return false;  }  status = eglInitialize(*display, 0, 0);  CheckError();  return status;}

bool PaPlayer::initStream(){    close();    PaStreamParameters outputParameters;    PaError err;    outputParameters.device = Pa_GetDefaultOutputDevice(); /* default output device */    if (outputParameters.device == paNoDevice) {       m_lastError = "No default output device.";       return false;    }    outputParameters.channelCount = m_wavFile->channelsCount();       /* stereo/mono output */    outputParameters.sampleFormat = paFloat32; /* 32 bit floating point output */    outputParameters.suggestedLatency = Pa_GetDeviceInfo( outputParameters.device )->defaultLowOutputLatency;    outputParameters.hostApiSpecificStreamInfo = NULL;    const double sampleRate = m_wavFile->audioSampleRate();    const unsigned int framesPerBuffer = 64;    err = Pa_OpenStream(              &m_stream,              NULL, // no input              &outputParameters,              sampleRate,              framesPerBuffer,              paClipOff,      // we won't output out of range samples so don't bother clipping them              wavPlayCallback,              this );    CheckError(err);    err = Pa_SetStreamFinishedCallback( m_stream, &StreamFinished );    CheckError(err);    err = Pa_StartStream( m_stream );    CheckError(err);    return true;}

//  Write a socketwxInt32 BufferedSocket::SendData(wxInt32 Timeout){       CreateSocket();    // create a transfer buffer, from memory stream to socket    wxStopWatch sw;    // clear it    memset(sData, 0, sizeof(sData));        // copy data    wxInt32 actual_size = send_buf->CopyTo(sData, MAX_PAYLOAD);        // set the start ping    // (Horrible, needs to be improved)    SendPing = sw.Time();                    // send the data    if (!Socket->WaitForWrite(0,Timeout))    {        CheckError();                SendPing = 0;        RecvPing = 0;                DestroySocket();                return 0;    }    else        Socket->SendTo(to_addr, sData, actual_size);        CheckError();                // return the amount of bytes sent    return Socket->LastCount();}

HRESULT CModuleConfiguration::GetString(IAppHostElement* section, LPCWSTR propertyName, LPWSTR* value){	HRESULT hr = S_OK;    BSTR sysPropertyName = NULL;    BSTR sysPropertyValue = NULL;    IAppHostProperty* prop = NULL;	CheckNull(value);	*value = NULL;	ErrorIf(NULL == (sysPropertyName = SysAllocString(propertyName)), ERROR_NOT_ENOUGH_MEMORY);	CheckError(section->GetPropertyByName(sysPropertyName, &prop));	CheckError(prop->get_StringValue(&sysPropertyValue));	ErrorIf(NULL == (*value = new WCHAR[wcslen(sysPropertyValue) + 1]), ERROR_NOT_ENOUGH_MEMORY);	wcscpy(*value, sysPropertyValue);Error:    if ( sysPropertyName )    {        SysFreeString(sysPropertyName);        sysPropertyName = NULL;    }    if ( sysPropertyValue )    {        SysFreeString(sysPropertyValue);        sysPropertyValue = NULL;    }    if (prop)    {        prop->Release();        prop = NULL;    }    return hr;}

bool Init (GetProcAddressCallback callback){    std::vector <std::string> needed_extensions = {            "GL_ARB_separate_shader_objects",            "GL_ARB_sampler_objects",            "GL_ARB_direct_state_access"    };    std::stringstream version;    int major, minor;#ifdef _WIN32	internal::_opengl32dllhandle = LoadLibrary ("OPENGL32.DLL");	internal::_usergetprocaddress = callback;	InitPrototypes (internal::_getprocaddress);#else    InitPrototypes (callback);#endif    if (!GetString || GetString == (PFNGLGETSTRINGPROC) oglp::Unsupported) {#ifdef OGLP_THROW_EXCEPTIONS		throw std::runtime_error ("No entry point for glGetString found.");#else        return false;#endif    }    version << GetString (GL_VERSION);    CheckError ();    version >> major;    version.ignore (1);    version >> minor;    if (major < 3) {#ifdef OGLP_THROW_EXCEPTIONS		throw std::runtime_error ("OpenGL version 3.0 or higher is required.");#else        return false;#endif    }    for (std::string &extension : needed_extensions) {        if (!IsExtensionSupported (extension)) {#ifdef OGLP_THROW_EXCEPTIONS			throw std::runtime_error (extension + " is required.");#else            return false;#endif        }    }    return true;}

int STEAM_fputc(int c, FILE *stream){	unsigned char chr = (unsigned char)c;	SteamHandle_t hndl = (SteamHandle_t)stream;	int n;	TSteamError steamError;	n = SteamWriteFile(&chr, sizeof(chr), 1, hndl, &steamError);	if ( n != 1 || steamError.eSteamError != eSteamErrorNone )	{		CheckError((FILE *)hndl, &steamError);		return EOF;	}	return c;}

//-----------------------------void GameMain(){  DDraw->FillSurface(DDraw->DDSBack,0) ;  //turn  CheckAction(mouse,EditInfo,world) ;  mouse.button = mouse_NO ;  //map scroll  ThisTickCount = GetTickCount() ;  if(ThisTickCount-MouseScrollTickCount>map_scroll_DELAY)  {    MouseScrollTickCount=ThisTickCount ;    MoveMapByMouse(mouse.x,mouse.y,                   (world->player[player_ID]).current_x_screen,(world->player[player_ID]).current_y_screen,                   screen_HEIGHT,screen_WIDTH) ;  } ;  //drawind  res=world->Draw(player_ID,screen,DDraw->DDSBack) ; // draw world  CheckError(res,"world->Draw") ;  if(mouse.x_frame>=0&&mouse.y_frame>=0)                                                                  //  {                                                                                                       //  Draw    res=(mouse.sprite)->Draw(DDraw->DDSBack,(mouse.x>>5)<<5,(mouse.y>>5)<<5,mouse.x_frame,mouse.y_frame) ;//  mouse    CheckError(res,"mouse->Draw") ;                                                                       //  } ;                                                                                                     //

void AudioChannel::SetVolume(float newVolume){	volume = std::max(newVolume, 0.0f);	if (curSources.empty())		return;	std::lock_guard<spring::recursive_mutex> lck(soundMutex);	for (auto it = curSources.begin(); it != curSources.end(); ++it) {		(*it)->UpdateVolume();	}	CheckError("AudioChannel::SetVolume");}

static int GetBooleanOptIndex(lua_State *L, GLenum pname) /* index is optional */    {    GLboolean data;    GLuint index;    if(!lua_isnoneornil(L, 2))        {        index = luaL_checkinteger(L, 2);        glGetBooleani_v(pname, index, &data);        }    else        glGetBooleanv(pname, &data);    CheckError(L);    lua_pushboolean(L, data);    return 1;    }

boolqtCanvas::Impl::setupMovie(){	OSErr err;	Handle dataRefH = nil;	OSType dataRefType = 0;		err = QTNewDataReferenceFromFullPathCFString(			mPath, (UInt32)kQTNativeDefaultPathStyle, 0,			&dataRefH, &dataRefType);    CheckError(err, "QTNewDataReferenceFromFullPathCFString");	CreateMovieStorage(dataRefH, dataRefType,			'TVOD', smSystemScript,			createMovieFileDeleteCurFile |				createMovieFileDontCreateResFile |				newMovieActive,			&mDataHandler, &mMovie);    CheckMoviesError("CreateMovieStorage");    CheckError((OSErr)((nil != mMovie) ? noErr : -1), "CreateMovieStorage movie");        return (err == noErr) && (GetMoviesError() == noErr) && (nil != mMovie);}

voidqtCanvas::Impl::setupImage(){    MacSetRect(&mFrame, 0, 0, mWidth, mHeight);        mImageStride = mWidth * 4;    mImageData = new unsigned char[mImageStride * mHeight];    OSErr err;	err = QTNewGWorldFromPtr(&mGWorld,				k32ARGBPixelFormat, &mFrame,				nil, nil, (GWorldFlags)0,				mImageData, mImageStride);    CheckError(err, "QTNewGWorldFromPtr");}

unsigned int STEAM_FileSize( FILE *file ){	SteamHandle_t hFile = (SteamHandle_t)file;	TSteamError steamError;	unsigned int result;	if ( STEAMtrackingProgress )	{		DoEventTic(FALSE);	}	result = SteamSizeFile(hFile, &steamError);	CheckError(file, &steamError);	return result;}

int STEAM_findclose(long dir){	SteamHandle_t hDir = (SteamHandle_t)dir;	TSteamError steamError;	int result;	if ( STEAMtrackingProgress )	{		DoEventTic(FALSE);	}	result = SteamFindClose(hDir, &steamError);	CheckError(NULL, &steamError);	return result;}

void SimCudaHelper::Initialize(int cudaDevice){    cudaDevice = Init(cudaDevice);    cudaError res;    // From CUDA prog guide: cudaSetDevice()and cudaGLSetGLDevice() are mutually exclusive.    res = cudaSetDevice(cudaDevice);    if (res != cudaSuccess)    {        CheckError(res, "cudaGetDeviceCount failed");    }    else    {        cout << "CUDA: Successful cudaSetDevice, using device " << cudaDevice << "/n";    }}

// Sets the outgoing addressvoid BufferedSocket::SetRemoteAddress(const wxString &Address, const wxInt16 &Port){    struct hostent *he;    if((he = gethostbyname((const char *)Address.char_str())) == NULL)    {        CheckError();        return;    }    m_RemoteAddress.sin_family = PF_INET;    m_RemoteAddress.sin_port = htons(Port);    m_RemoteAddress.sin_addr = *((struct in_addr *)he->h_addr);    memset(m_RemoteAddress.sin_zero, '/0', sizeof m_RemoteAddress.sin_zero);}

int STEAM_fputs(const char *string, FILE *stream){	SteamHandle_t hndl = (SteamHandle_t)stream;	int len = strlen(string);	int n;	TSteamError steamError;	n = SteamWriteFile((void*)string, sizeof(char), len, hndl, &steamError);	if ( n != len || steamError.eSteamError != eSteamErrorNone )	{		CheckError((FILE *)hndl, &steamError);		return EOF;	}	return 1;}