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

/***	PUBLIC	Metodo ClearSynonym	Realiza a delecao de todas as definicoes de sinonimos feita para o	objeto LTC_SYNONYM.	Parameters:		-	Return:		0 se operacao OK ou negativo caso contrario.	Comments:		-***/intLBSC_Base::ClearSynonym(){	PRINTLOG( _clLBSLog, ("LBSC_Base::ClearSynonym") );	CLBAutoRegCrit	AutoRegCrit(&rcRegCrit);	if( !plbscisIndexSystem ){		ERETURN( LBSE_INVALIDINDEXSYSTEM );	}	if( pltcSynonym ){		int iRet = pltcSynonym->LT_ClearSynonym();		if( iRet == 0 ){			LTC_SYNONYM *pAux = plbscisIndexSystem->LT_SetSynonym( NULL );			if( pAux ){				delete pAux;			}			SetError( plbscisIndexSystem->GetError() );		} else {			SetError( pltcSynonym->GetError() );		}		return( iRet );	}	ERETURN( LBSE_NOMEMORY );}

/***	PRIVATE	Metodo GetUserType	Obtem o tipo de um usuario	Parameters:		-		-	Return:		- o tipo do usuario ou um valor negativo indicando erro	Comments:		-***/longLBSC_Session::GetUserType( LBSC_Base *pUDB, char *szUserName ){	PRINTLOG( _clLBSLog, ("LBSC_Session::GetUserType") );	if( !pUDB || !szUserName ){		ERETURN( LBSE_BADARG );	}	// procurar o usuario na UDB (a password nao interessa)	int iRet = FindUser( pUDB, szUserName, "$" );	if( iRet != LBS_OK && iRet != LBSE_INVALIDPASSWORD ){		// fudeu		ERETURN( iRet );	}	LBSC_Field	*pf = (*pUDB)[ USERBASEUSERTYPE ];	if( !pf ){		ERETURN( LBSE_BADUSERBASE );	}	LBSC_Data	*pd = (*pf)[ 0 ];	if( !pd ){		ERETURN( LBSE_BADUSERBASE );	}	long lType = (long) (*pd);	SetError( LBS_OK );	return( lType );}

int_tmf_bksp(struct fdinfo *fio, struct ffsw *stat){	struct tmfio	*xf_info;	register int	ret;	int		usertm;	xf_info	= (struct tmfio *)fio->lyr_info;	if (xf_info->tmf_tpos) {		if (_tmf_tpwait (xf_info) < 0) {			ERETURN(stat, errno, 0);		}	}/* *	If the file's been writing, flush out any unwritten data. */	if (xf_info->rwflag == WRITIN) {		if (_tmf_flush(fio, stat) < 0) {			return(ERR);		}	}/* *	Now backspace. */		ret	= _tmf_stpos(fio, FP_TPOS_BACK, 1, 0, 0, 0, &usertm, stat);	if (ret < 0 && stat->sw_error != ETBOF)		return(ERR);	xf_info->rwflag	= POSITIN;	return(0);}

ACL_CFG_LINE *acl_cfg_line_new(const char **value, int ncount){	ACL_CFG_LINE *cfg_line = NULL;	int   i;#undef	ERETURN#define	ERETURN(x) do { /	if (cfg_line == NULL) /		return (x); /	if (cfg_line->value == NULL) { /		acl_myfree(cfg_line); /		return (x); /	} /	for (i = 0; i < cfg_line->ncount; i++) { /		if (cfg_line->value[i] == NULL) /			break; /		acl_myfree(cfg_line->value[i]); /	} /	acl_myfree(cfg_line->value); /	acl_myfree(cfg_line); /	return (x); /} while (0);	if (value == NULL || ncount <= 0)		return (NULL);	cfg_line = (ACL_CFG_LINE *) acl_mycalloc(1, sizeof(ACL_CFG_LINE));	if (cfg_line == NULL)		return (NULL);	cfg_line->value = (char **) acl_mycalloc(1 + ncount, sizeof(char *));	if (cfg_line->value == NULL)		ERETURN (NULL);	cfg_line->pdata = NULL;	cfg_line->ncount = 0;	cfg_line->line_number = 0;	for (i = 0; i < ncount; i++) {		cfg_line->value[i] = acl_mystrdup(value[i]);		if (cfg_line->value[i] == NULL)			ERETURN (NULL);		cfg_line->ncount++;	}	return (cfg_line);}

/***	PUBLIC	Metodo LoadMasks	Carrega a lista de mascaras a partir de um arquivo.	Parameters:		- szFileName: nome do arquivo( inclusive path ).	Return:		- 0 se operacao OK ou negativo caso contrario.	Comments:        	-***/intLBSC_Base::LoadMasks( char *szFileName ){	PRINTLOG( _clLBSLog, ("LBSC_Base::LoadMasks") );	CLBAutoRegCrit	AutoRegCrit(&rcRegCrit);	if( pltcMaskList ){		pltcMaskList->LT_DelAllTerm();		int	iRet = pltcMaskList->LT_LoadTermList( szFileName );		if( iRet != OK ){			pltcMaskList->LT_DelAllTerm();			ERETURN( LBSE_ERROR );		}		ERETURN( LBS_OK );	}	ERETURN( LBSE_NOMEMORY );}

_er90b_lseek(struct fdinfo *fio, int pos, int whence, struct ffsw *stat){int ret;	if (whence == 0 && pos == 0) {		ret = _er90b_rewd((ER90BYT *)fio->lyr_info);		if (ret < 0)			ERETURN(stat, errno, 0);		fio->ateof = 0;		fio->ateod = 0;		SETSTAT(stat, FFBOD, 0);	}	else {		ERETURN(stat, FDC_ERR_NOSUP, 0);	}	fio->rwflag = POSITIN;	return (0);}

intpsbuf_get_8(struct puffs_framebuf *pb, uint64_t *val){	int rv;	rv = puffs_framebuf_getdata(pb, val, 8);	BE64TOH(*val);	ERETURN(rv);}

intpsbuf_get_4(struct puffs_framebuf *pb, uint32_t *val){	int rv;	rv = puffs_framebuf_getdata(pb, val, 4);	BE32TOH(*val);	ERETURN(rv);}

intpsbuf_get_2(struct puffs_framebuf *pb, uint16_t *val){	int rv;	rv = puffs_framebuf_getdata(pb, val, 2);	BE16TOH(*val);	ERETURN(rv);}

/***	PUBLIC	Metodo DeletePhone	Deleta da lista de fonemas as definicoes desejadas. Estas definicoes	deverao estar na string szPhoneArray separadas por um espaco em branco.	Parameters:		- szPhoneArray: String de caracteres, terminado com '/0', que		contera as definicoes dos fonemas. Cada definicao (fonema) devera 		estar separada por um caracter branco;	Return:		- 0 se operacao OK ou negativo caso contrario.	Comments:		-***/intLBSC_Base::DeletePhone( char *szPhoneArray ){	PRINTLOG( _clLBSLog, ("LBSC_Base::DeletePhone") );	CLBAutoRegCrit	AutoRegCrit(&rcRegCrit);	LTC_TERMLIST	*pltcTermAux = new LTC_TERMLIST;	if( !pltcTermAux ){		ERETURN( LBSE_NOMEMORY );	}	if( !pltcPhone ){		delete pltcTermAux;		ERETURN( LBSE_NOMEMORY );	}	if( !plbscisIndexSystem ){		delete pltcTermAux;		ERETURN( LBSE_INVALIDINDEXSYSTEM );	}	if( pltcTermAux->LT_BuildTermList( szPhoneArray ) != LBS_OK ){		delete pltcTermAux;		SetError( pltcTermAux->GetError() );		return( LBSE_ERROR );	}	int iRet = pltcPhone->LT_DeletePhone( pltcTermAux );	if( iRet == 0 ){		LTC_PHONE *pAux = plbscisIndexSystem->LT_SetPhone( pltcPhone );		if( pAux ){			delete pAux;		}		SetError( plbscisIndexSystem->GetError() );	} else {		SetError( pltcPhone->GetError() );	}	delete pltcTermAux;	return( iRet );}

/***	PUBLIC	Metodo AddSynonym	Adiciona um conjunto de sinonimos (szSynonymArray) para o termo ptctTerm	Parameters:		- szTerm: String de caracteres, terminado com '/0', indicando		qual e o termo que possui o conjunto de sinonimos;		- szSynonymArray: String de caracteres, terminado com '/0',		que contera as diversas palavras que sao sinonimos do termo		passado como parametro. As palavras desta string deverao estar		separadas por um caracter branco;		- iFlag: Flag indicativo para a utilizacao, ou nao, de		bidirecionamento ou associatividade.	Return:		- 0 se operacao OK ou negativo caso contrario.	Comments:		-***/intLBSC_Base::AddSynonym( char *szTerm, char *szSynonymArray, int iFlag ){	PRINTLOG( _clLBSLog, ("LBSC_Base::AddSynonym") );	CLBAutoRegCrit	AutoRegCrit(&rcRegCrit);	LTC_TERMLIST	*pltcTermAux = new LTC_TERMLIST;	if( !pltcTermAux ){		ERETURN( LBSE_NOMEMORY );	}	if( !pltcSynonym ){		delete pltcTermAux;		ERETURN( LBSE_NOMEMORY );	}	if( !plbscisIndexSystem ){		delete pltcTermAux;		ERETURN( LBSE_INVALIDINDEXSYSTEM );	}	if( pltcTermAux->LT_BuildTermList( szSynonymArray ) != LBS_OK ){		SetError( pltcTermAux->GetError() );		delete pltcTermAux;		return( LBSE_ERROR );	}	int iRet = pltcSynonym->LT_AddSynonym( szTerm, pltcTermAux, iFlag );	if( iRet == 0 ){		LTC_SYNONYM *pAux = plbscisIndexSystem->LT_SetSynonym( pltcSynonym );		if( pAux ){			delete pAux;		}		SetError( plbscisIndexSystem->GetError() );	} else {		SetError( pltcSynonym->GetError() );	}	delete pltcTermAux;	return( iRet );}

static int nr_ice_crypto_openssl_hmac_sha1(UCHAR *key, int key_l, UCHAR *buf, int buf_l, UCHAR digest[20]) {  unsigned int rl;  HMAC(EVP_sha1(),    key, key_l, buf, buf_l, digest, &rl);  if (rl != 20)    ERETURN(R_INTERNAL);  return 0;}

/***	PUBLIC	Metodo OLNot	Faz um batimento NOT entre duas listas de ocorrencias        e gera uma terceira lista	Parameters:		- lbscTicket : o ticket de seguranca		- iHandle1 : handle da primeira LO		- iHandle2 : handle da segunda LO	Return:		- o handle da LO gerada ou um erro (valor negativo)	Comments:        	- a LO gerada NAO se torna a corrente                  (ela nao eh habilitada)***/intLBSC_Base::OLNot( const LBSC_Ticket *lbscTicket, int iHandle1, int iHandle2 ){	PRINTLOG( _clLBSLog, ("LBSC_Base::OLNot") );	CLBAutoRegCrit	AutoRegCrit(&rcRegCrit);	if( plbscsOwnerSession->TicketIsOk( lbscTicket ) != 0 ){		ERETURN( LBSE_TICKETNOTOK );	}	return( LogicalOp( OL_NOT, iHandle1, iHandle2 ) );}

/**********************************************************// Function name	: LBSC_Session::ValidUser// Description	    : // Return type		: int // Argument         :  const LBSC_Ticket *plbscTicketPar// Argument         : const char *szUserName// Argument         : const char *szPassword**********************************************************/int LBSC_Session::ValidUser( const LBSC_Ticket *plbscTicketPar, const char *szUserName, const char *szPassword ){	PRINTLOG( _clLBSLog, ("LBSC_Session::ValidUser") );	// Verifica a validade do ticket de seguranca	if( TicketIsOk( plbscTicketPar ) != 0 ){		ERETURN( LBSE_TICKETNOTOK );	}	// Abrir a UDB	LBSC_Base	*pUdb = new LBSC_Base( plbscTicketPar, (char*) strUDBLogged, this );	if( !pUdb ){		ERETURN( LBSE_NOMEMORY );	}	if( !pUdb->BaseObjOk() ){		delete pUdb;		ERETURN( LBSE_UBNOTOK );	}	int iRet = FindUser( pUdb, szUserName, szPassword );	delete pUdb;	ERETURN( iRet );	}

/* * This routine is like ffopen, except it expects all parameters */ffopenf(const char *name, int flags, mode_t mode, long cbits, int cblks,	struct ffsw *pstat){	int		narg;	_ffopen_t	fd;	int		retfd;	int		aifound;	union spec_u	*fdspec;	struct gl_o_inf	gloinf;	assign_info	ai;	struct fdinfo	*nfio;	extern union spec_u *_g_fdc_spec(); 	aifound = _assign_asgcmd_info(name, -1, ASN_G_FF | ASN_G_ALL, &ai,			NULL, 1);	if (aifound == -1) {		ERETURN(pstat, errno, 0);	}	if (aifound == 1 && ai.F_filter_flg)		fdspec = &ai.F_filter[0];	else		fdspec = NULL;	(void) memset(&gloinf, 0, sizeof(gloinf));        gloinf.aip	= aifound ? &ai : NULL;	fd = _ffopen(name, flags, mode, fdspec, pstat, cbits, cblks, NULL,		&gloinf);#if defined(_CRAY1) || defined(__mips)	if (fd != _FFOPEN_ERR && MULTI_ON) {		nfio = NULL;		if (_ff_top_lock(fd, &nfio, pstat) < 0)			fd = _FFOPEN_ERR;		if (nfio != NULL)			fd = (_ffopen_t)nfio;	}#endif	/*	 * ffopen returns an int. Call a routine which associates an	 * int with what is returned by _ffopen 	 */#if	defined(__mips) || defined(_LITTLE_ENDIAN)	retfd = _ff_fdinfo_to_int(fd, pstat);#else	retfd = (int)fd;#endif	/* should check chain of layers here for sanity */	return(retfd);}

/***	PUBLIC	Metodo SetMask	Define um conjunto de mascaras de reconhecimento de termos que poderao	ser indexados como data, hora e valor. Esta definicao e feita por sistema	de indices	Parameters:		- szMasks: Apontador para uma cadeia de caracteres com a		lista de mascaras que sera setado como lista de mascara		corrente de um determinado sistema de indices;		- iIndex: Informa para qual indice a lista de mascaras esta		sendo setada. Podera ser para o indice de Data (DATETREE),		Hora (TIMETREE) ou Valor (VALUETREE).		- iTypeOfHeaderMask: Representa o tipo de mascara que deve ser		settada em fun
C++ ERL_COUNT函数代码示例
C++ EQUIV函数代码示例