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:
		-

***/
int
LBSC_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:
		-

***/
long
LBSC_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:
        	-


***/
int
LBSC_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);
}

int
psbuf_get_8(struct puffs_framebuf *pb, uint64_t *val)
{
	int rv;

	rv = puffs_framebuf_getdata(pb, val, 8);
	BE64TOH(*val);

	ERETURN(rv);
}

int
psbuf_get_4(struct puffs_framebuf *pb, uint32_t *val)
{
	int rv;

	rv = puffs_framebuf_getdata(pb, val, 4);
	BE32TOH(*val);

	ERETURN(rv);
}

int
psbuf_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:
		-

***/
int
LBSC_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:
		-

***/
int
LBSC_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)

***/
int
LBSC_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);
}