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

/* {{{ mysqlnd_net::read_compressed_packet_from_stream_and_fill_read_buffer */static enum_func_statusMYSQLND_METHOD(mysqlnd_net, read_compressed_packet_from_stream_and_fill_read_buffer)		(MYSQLND_NET * net, size_t net_payload_size, MYSQLND_STATS * conn_stats, MYSQLND_ERROR_INFO * error_info){	size_t decompressed_size;	enum_func_status retval = PASS;	zend_uchar * compressed_data = NULL;	zend_uchar comp_header[COMPRESSED_HEADER_SIZE];	DBG_ENTER("mysqlnd_net::read_compressed_packet_from_stream_and_fill_read_buffer");	/* Read the compressed header */	if (FAIL == net->data->m.network_read_ex(net, comp_header, COMPRESSED_HEADER_SIZE, conn_stats, error_info)) {		DBG_RETURN(FAIL);	}	decompressed_size = uint3korr(comp_header);	/* When decompressed_size is 0, then the data is not compressed, and we have wasted 3 bytes */	/* we need to decompress the data */	if (decompressed_size) {		compressed_data = mnd_emalloc(net_payload_size);		if (FAIL == net->data->m.network_read_ex(net, compressed_data, net_payload_size, conn_stats, error_info)) {			retval = FAIL;			goto end;		}		net->uncompressed_data = mysqlnd_create_read_buffer(decompressed_size);		retval = net->data->m.decode(net->uncompressed_data->data, decompressed_size, compressed_data, net_payload_size);		if (FAIL == retval) {			goto end;		}	} else {		DBG_INF_FMT("The server decided not to compress the data. Our job is easy. Copying %u bytes", net_payload_size);		net->uncompressed_data = mysqlnd_create_read_buffer(net_payload_size);		if (FAIL == net->data->m.network_read_ex(net, net->uncompressed_data->data, net_payload_size, conn_stats, error_info)) {			retval = FAIL;			goto end;		}	}end:	if (compressed_data) {		mnd_efree(compressed_data);	}	DBG_RETURN(retval);}

/* {{{ mysqlnd_com_init_db_run */static enum_func_statusmysqlnd_com_init_db_run(void *cmd){	struct st_mysqlnd_protocol_com_init_db_command * command = (struct st_mysqlnd_protocol_com_init_db_command *) cmd;	enum_func_status ret = FAIL;	MYSQLND_CONN_DATA * conn = command->context.conn;	const MYSQLND_CSTRING db = command->context.db;	func_mysqlnd_protocol_payload_decoder_factory__send_command send_command = conn->payload_decoder_factory->m.send_command;	func_mysqlnd_protocol_payload_decoder_factory__send_command_handle_response send_command_handle_response = conn->payload_decoder_factory->m.send_command_handle_response;	DBG_ENTER("mysqlnd_com_init_db_run");	ret = send_command(conn->payload_decoder_factory, COM_INIT_DB, (zend_uchar*) command->context.db.s, command->context.db.l, FALSE,					   &conn->state,					   conn->error_info,					   conn->upsert_status,					   conn->stats,					   conn->m->send_close,					   conn);	if (PASS == ret) {		ret = send_command_handle_response(conn->payload_decoder_factory, PROT_OK_PACKET, FALSE, COM_INIT_DB, TRUE,										   conn->error_info, conn->upsert_status, &conn->last_message, conn->persistent);	}	/*	  The server sends 0 but libmysql doesn't read it and has established	  a protocol of giving back -1. Thus we have to follow it :(	*/	UPSERT_STATUS_SET_AFFECTED_ROWS_TO_ERROR(conn->upsert_status);	if (ret == PASS) {		if (conn->connect_or_select_db.s) {			mnd_pefree(conn->connect_or_select_db.s, conn->persistent);		}		conn->connect_or_select_db.s = mnd_pestrndup(db.s, db.l, conn->persistent);		conn->connect_or_select_db.l = db.l;		if (!conn->connect_or_select_db.s) {			/* OOM */			SET_OOM_ERROR(conn->error_info);			ret = FAIL;		}	}	DBG_RETURN(ret);}

NTSTATUSCCaptureDevice::DispatchQueryCapabilities(    _In_ PKSDEVICE Device,    _In_ PIRP Irp,    _Inout_ PDEVICE_CAPABILITIES Capabilities){    PAGED_CODE();    DBG_ENTER("()");    NTSTATUS Status =        Recast(Device)->        PnpQueryCapabilities( Irp, Capabilities );    DBG_LEAVE("()=0x%08X", Status);    return Status;}

/* {{{ mysqlnd_mempool_create */PHPAPI MYSQLND_MEMORY_POOL *mysqlnd_mempool_create(size_t arena_size){	/* We calloc, because we free(). We don't mnd_calloc()  for a reason. */	MYSQLND_MEMORY_POOL * ret = mnd_ecalloc(1, sizeof(MYSQLND_MEMORY_POOL));	DBG_ENTER("mysqlnd_mempool_create");	if (ret) {		ret->get_chunk = mysqlnd_mempool_get_chunk;		ret->free_size = ret->arena_size = arena_size ? arena_size : 0;		ret->refcount = 0;		/* OOM ? */		ret->arena = mnd_emalloc(ret->arena_size);		if (!ret->arena) {			mysqlnd_mempool_destroy(ret);			ret = NULL;		}	}	DBG_RETURN(ret);}

/* {{{ mysqlnd_vio::dtor */static voidMYSQLND_METHOD(mysqlnd_vio, dtor)(MYSQLND_VIO * const vio, MYSQLND_STATS * const stats, MYSQLND_ERROR_INFO * const error_info){	DBG_ENTER("mysqlnd_vio::dtor");	if (vio) {		vio->data->m.free_contents(vio);		vio->data->m.close_stream(vio, stats, error_info);		if (vio->cmd_buffer.buffer) {			DBG_INF("Freeing cmd buffer");			mnd_pefree(vio->cmd_buffer.buffer, vio->persistent);			vio->cmd_buffer.buffer = NULL;		}		mnd_pefree(vio->data, vio->data->persistent);		mnd_pefree(vio, vio->persistent);	}	DBG_VOID_RETURN;}

/* {{{ ps_fetch_date */staticvoid ps_fetch_date(zval *zv, const MYSQLND_FIELD * const field,				   unsigned int pack_len, zend_uchar **row,				   zend_bool as_unicode TSRMLS_DC){	struct st_mysqlnd_time t = {0};	unsigned int length; /* First byte encodes the length*/	char * value;	DBG_ENTER("ps_fetch_date");	if ((length = php_mysqlnd_net_field_length(row))) {		zend_uchar *to= *row;		t.time_type= MYSQLND_TIMESTAMP_DATE;		t.neg= 0;		t.second_part = t.hour = t.minute = t.second = 0;		t.year	= (unsigned int) sint2korr(to);		t.month = (unsigned int) to[2];		t.day	= (unsigned int) to[3];		(*row)+= length;	} else {		memset(&t, 0, sizeof(t));		t.time_type = MYSQLND_TIMESTAMP_DATE;	}	length = mnd_sprintf(&value, 0, "%04u-%02u-%02u", t.year, t.month, t.day);	DBG_INF_FMT("%s", value);#if MYSQLND_UNICODE	if (!as_unicode) {#endif		ZVAL_STRINGL(zv, value, length, 1);		mnd_sprintf_free(value);#if MYSQLND_UNICODE	} else {		ZVAL_UTF8_STRINGL(zv, value, length, ZSTR_AUTOFREE);	}#endif	DBG_VOID_RETURN;}

/* {{{ mysqlnd_com_handshake_create_command */static struct st_mysqlnd_protocol_command *mysqlnd_com_handshake_create_command(va_list args){	struct st_mysqlnd_protocol_com_handshake_command * command;	DBG_ENTER("mysqlnd_com_handshake_create_command");	command = mnd_ecalloc(1, sizeof(struct st_mysqlnd_protocol_com_handshake_command));	if (command) {		command->context.conn = va_arg(args, MYSQLND_CONN_DATA *);		command->context.user = *va_arg(args, const MYSQLND_CSTRING *);		command->context.passwd = *va_arg(args, const MYSQLND_CSTRING *);		command->context.database = *va_arg(args, const MYSQLND_CSTRING *);		command->context.client_flags = va_arg(args, size_t);		command->parent.free_command = mysqlnd_com_no_params_free_command;		command->parent.run = mysqlnd_com_handshake_run;	}	DBG_RETURN((struct st_mysqlnd_protocol_command *) command);}

/* {{{ ps_fetch_float */static voidps_fetch_float(zval * zv, const MYSQLND_FIELD * const field, unsigned int pack_len, zend_uchar ** row){	float fval;	double dval;	DBG_ENTER("ps_fetch_float");	float4get(fval, *row);	(*row)+= 4;	DBG_INF_FMT("value=%f", fval);#ifndef NOT_FIXED_DEC# define NOT_FIXED_DEC 31#endif	dval = mysql_float_to_double(fval, (field->decimals >= NOT_FIXED_DEC) ? -1 : field->decimals);	ZVAL_DOUBLE(zv, dval);	DBG_VOID_RETURN;}

/** * ConfigMMCRegs - Used to configure the main memory registers in the JAGCore * @pAdapter: pointer to our adapter structure */void ConfigMMCRegs(struct et131x_adapter *pAdapter){	MMC_CTRL_t mmc_ctrl = { 0 };	DBG_ENTER(et131x_dbginfo);	/* All we need to do is initialize the Memory Control Register */	mmc_ctrl.bits.force_ce = 0x0;	mmc_ctrl.bits.rxdma_disable = 0x0;	mmc_ctrl.bits.txdma_disable = 0x0;	mmc_ctrl.bits.txmac_disable = 0x0;	mmc_ctrl.bits.rxmac_disable = 0x0;	mmc_ctrl.bits.arb_disable = 0x0;	mmc_ctrl.bits.mmc_enable = 0x1;	writel(mmc_ctrl.value, &pAdapter->CSRAddress->mmc.mmc_ctrl.value);	DBG_LEAVE(et131x_dbginfo);}

static void wl_adapter_detach(struct pcmcia_device *link){	struct net_device   *dev = link->priv;	/*--------------------------------------------------------------------*/	DBG_FUNC("wl_adapter_detach");	DBG_ENTER(DbgInfo);	DBG_PARAM(DbgInfo, "link", "0x%p", link);	wl_adapter_release(link);	if (dev) {		unregister_wlags_sysfs(dev);		unregister_netdev(dev);		wl_device_dealloc(dev);	}	DBG_LEAVE(DbgInfo);} /* wl_adapter_detach */

/* {{{ mysqlnd_mempool_free_chunk */static voidmysqlnd_mempool_free_chunk(MYSQLND_MEMORY_POOL * pool, MYSQLND_MEMORY_POOL_CHUNK * chunk){	DBG_ENTER("mysqlnd_mempool_free_chunk");	if (chunk->from_pool) {		/* Try to back-off and guess if this is the last block allocated */		if (chunk->ptr == (pool->arena + (pool->arena_size - pool->free_size - chunk->size))) {			/*				This was the last allocation. Lucky us, we can free				a bit of memory from the pool. Next time we will return from the same ptr.			*/			pool->free_size += chunk->size;		}	} else {		mnd_efree(chunk->ptr);	}	mnd_efree(chunk);	DBG_VOID_RETURN;}

void env_delete(word segm){	DBG_ENTER("env_delete", Suppl_env)	DBG_ARGUMENTS( ("env=%u", segm) )	chkMem 	unless_segm(segm) 		DBG_EXIT   	DBG_ARGUMENTS( ("effective env=%u", segm) )   	pokew(SEG2MCB(segm), MCB_OFF_OWNER, _psp); 	freeBlk(segm); 	chkMem 	/* Make sure the deleted segment won't be referenced */ 	env_relocateSegment(segm, 0);  	DBG_EXIT}

/* {{{ mysqlnd_command::stmt_close */static enum_func_statusMYSQLND_METHOD(mysqlnd_command, stmt_close)(MYSQLND_CONN_DATA * const conn, const zend_ulong stmt_id){	func_mysqlnd_protocol_payload_decoder_factory__send_command send_command = conn->payload_decoder_factory->m.send_command;	zend_uchar cmd_buf[MYSQLND_STMT_ID_LENGTH /* statement id */];	enum_func_status ret = FAIL;	DBG_ENTER("mysqlnd_command::stmt_close");	int4store(cmd_buf, stmt_id);	ret = send_command(conn->payload_decoder_factory, COM_STMT_CLOSE, cmd_buf, sizeof(cmd_buf), FALSE,					   &conn->state,					   conn->error_info,					   conn->upsert_status,					   conn->stats,					   conn->m->send_close,					   conn);	DBG_RETURN(ret);}

/* {{{ mysqlnd_com_quit_run */enum_func_statusmysqlnd_com_quit_run(void *cmd){	struct st_mysqlnd_protocol_com_quit_command * command = (struct st_mysqlnd_protocol_com_quit_command *) cmd;	enum_func_status ret = FAIL;	MYSQLND_CONN_DATA * conn = command->context.conn;	func_mysqlnd_protocol_payload_decoder_factory__send_command send_command = conn->payload_decoder_factory->m.send_command;	DBG_ENTER("mysqlnd_com_quit_run");	ret = send_command(conn->payload_decoder_factory, COM_QUIT, NULL, 0, TRUE,					   &conn->state,					   conn->error_info,					   conn->upsert_status,					   conn->stats,					   conn->m->send_close,					   conn);	DBG_RETURN(ret);}

INT32 CInvHead::ShowList(){	DBG_ENTER("CInvHead::ShowList");	CInvDet *p = pHead;	    //若为空链表	if (pHead == NULL)	{		DBG_ASSERT_WARNING(false,("The list is empty!"));		DBG_RETURN(FAILURE);	}	    //若为非空链表	while (p)	{		DBG_PRINT(("m_spbm = %s,", p->m_spbm.c_str() ));		p = p->pNext;	}	DBG_RETURN(SUCCESS);	}

/* {{{ mysqlnd_mempool_resize_chunk */static void *mysqlnd_mempool_resize_chunk(MYSQLND_MEMORY_POOL * pool, void * ptr, size_t old_size, size_t size){	DBG_ENTER("mysqlnd_mempool_resize_chunk");	/* Try to back-off and guess if this is the last block allocated */	if (ptr == pool->last	  && (ZEND_MM_ALIGNED_SIZE(size) <= ((char*)pool->arena->end - (char*)ptr))) {		/*			This was the last allocation. Lucky us, we can free			a bit of memory from the pool. Next time we will return from the same ptr.		*/		pool->arena->ptr = (char*)ptr + ZEND_MM_ALIGNED_SIZE(size);	} else {		void *new_ptr = mysqlnd_arena_alloc(&pool->arena, size);		memcpy(new_ptr, ptr, MIN(old_size, size));		pool->last = ptr = new_ptr;	}	DBG_RETURN(ptr);}

/* {{{ mysqlnd_com_stmt_fetch_run */static enum_func_statusmysqlnd_com_stmt_fetch_run(void *cmd){	struct st_mysqlnd_protocol_com_stmt_fetch_command * command = (struct st_mysqlnd_protocol_com_stmt_fetch_command *) cmd;	enum_func_status ret = FAIL;	MYSQLND_CONN_DATA * conn = command->context.conn;	func_mysqlnd_protocol_payload_decoder_factory__send_command send_command = conn->payload_decoder_factory->m.send_command;	DBG_ENTER("mysqlnd_com_stmt_fetch_run");	ret = send_command(conn->payload_decoder_factory, COM_STMT_FETCH, (zend_uchar*) command->context.payload.s, command->context.payload.l, FALSE,					   &conn->state,					   conn->error_info,					   conn->upsert_status,					   conn->stats,					   conn->m->send_close,					   conn);	DBG_RETURN(ret);}

char *StrQuote(const char * const s, const STR_QUOTES * const quotes){    char *result;    char *metachars;    const char *p;    const char *q;    int right, ch;    static char buf_l[2] = " ";    static char buf_r[2] = " ";    DBG_ENTER("StrQuote", Suppl_dynstr)    assert(quotes);    DBG_ARGUMENTS( ("s=/"%s/"", s) )    if(!s) {        eno_set(EINVAL);        DBG_RETURN_S(0)    }

/* {{{ mysqlnd_res_meta::free */static voidMYSQLND_METHOD(mysqlnd_res_meta, free)(MYSQLND_RES_METADATA * meta){	int i;	MYSQLND_FIELD *fields;	DBG_ENTER("mysqlnd_res_meta::free");	if ((fields = meta->fields)) {		DBG_INF("Freeing fields metadata");		i = meta->field_count;		while (i--) {			php_mysqlnd_free_field_metadata(fields++);		}		meta->fields = NULL;	}	DBG_INF("Freeing metadata structure");	DBG_VOID_RETURN;}

/**  Process the transmit completion  This routine use ::EslSocketTxComplete to perform the transmit  completion processing for data packets.  This routine is called by the UDPv4 network layer when a data  transmit request completes.  @param [in] Event     The normal transmit completion event  @param [in] pIo       Address of an ::ESL_IO_MGMT structure**/VOIDEslUdp6TxComplete (  IN EFI_EVENT Event,  IN ESL_IO_MGMT * pIo  ){  UINT32 LengthInBytes;  ESL_PORT * pPort;  ESL_PACKET * pPacket;  ESL_SOCKET * pSocket;  EFI_STATUS Status;    DBG_ENTER ( );    //  //  Locate the active transmit packet  //  pPacket = pIo->pPacket;  pPort = pIo->pPort;  pSocket = pPort->pSocket;  //  //  Get the transmit length and status  //  LengthInBytes = pPacket->Op.Udp6Tx.TxData.DataLength;  pSocket->TxBytes -= LengthInBytes;  Status = pIo->Token.Udp6Tx.Status;  //  //  Complete the transmit operation  //  EslSocketTxComplete ( pIo,                        LengthInBytes,                        Status,                        "UDP ",                        &pSocket->pTxPacketListHead,                        &pSocket->pTxPacketListTail,                        &pPort->pTxActive,                        &pPort->pTxFree );  DBG_EXIT ( );}

/** * et131x_stats - Return the current device statistics. * @netdev: device whose stats are being queried * * Returns 0 on success, errno on failure (as defined in errno.h) */struct net_device_stats *et131x_stats(struct net_device *netdev){	struct et131x_adapter *adapter = netdev_priv(netdev);	struct net_device_stats *stats = &adapter->net_stats;	CE_STATS_t *devstat = &adapter->Stats;	DBG_ENTER(et131x_dbginfo);	stats->rx_packets = devstat->ipackets;	stats->tx_packets = devstat->opackets;	stats->rx_errors = devstat->length_err + devstat->alignment_err +	    devstat->crc_err + devstat->code_violations + devstat->other_errors;	stats->tx_errors = devstat->max_pkt_error;	stats->multicast = devstat->multircv;	stats->collisions = devstat->collisions;	stats->rx_length_errors = devstat->length_err;	stats->rx_over_errors = devstat->rx_ov_flow;	stats->rx_crc_errors = devstat->crc_err;	// NOTE: These stats don't have corresponding values in CE_STATS, so we're	//       going to have to update these directly from within the TX/RX code	//stats->rx_bytes            = 20; //devstat->;	//stats->tx_bytes            = 20; //devstat->;	//stats->rx_dropped          = devstat->;	//stats->tx_dropped          = devstat->;	// NOTE: Not used, can't find analogous statistics	//stats->rx_frame_errors     = devstat->;	//stats->rx_fifo_errors      = devstat->;	//stats->rx_missed_errors    = devstat->;	//stats->tx_aborted_errors   = devstat->;	//stats->tx_carrier_errors   = devstat->;	//stats->tx_fifo_errors      = devstat->;	//stats->tx_heartbeat_errors = devstat->;	//stats->tx_window_errors    = devstat->;	DBG_LEAVE(et131x_dbginfo);	return stats;}

/** * et131x_ioctl_mii - The function which handles MII IOCTLs * @netdev: device on which the query is being made * @reqbuf: the request-specific data buffer * @cmd: the command request code * * Returns 0 on success, errno on failure (as defined in errno.h) */int et131x_ioctl_mii(struct net_device *netdev, struct ifreq *reqbuf, int cmd){	int status = 0;	struct et131x_adapter *pAdapter = netdev_priv(netdev);	struct mii_ioctl_data *data = if_mii(reqbuf);	DBG_ENTER(et131x_dbginfo);	switch (cmd) {	case SIOCGMIIPHY:		DBG_VERBOSE(et131x_dbginfo, "SIOCGMIIPHY/n");		data->phy_id = pAdapter->Stats.xcvr_addr;		break;	case SIOCGMIIREG:		DBG_VERBOSE(et131x_dbginfo, "SIOCGMIIREG/n");		if (!capable(CAP_NET_ADMIN)) {			status = -EPERM;		} else {			status = MiRead(pAdapter,					data->reg_num, &data->val_out);		}		break;	case SIOCSMIIREG:		DBG_VERBOSE(et131x_dbginfo, "SIOCSMIIREG/n");		if (!capable(CAP_NET_ADMIN)) {			status = -EPERM;		} else {			status = MiWrite(pAdapter, data->reg_num,					 data->val_in);		}		break;	default:		status = -EOPNOTSUPP;	}	DBG_LEAVE(et131x_dbginfo);	return status;}

PGPErrorPMAddConfig(NDIS_HANDLE handle, PGPnetKernelConfig *pConfig){	PGPnetPMContext		*pContext = (PGPnetPMContext*) handle;	NDIS_STATUS			status;	DBG_FUNC("PMAddConfig")    DBG_ENTER();	/* if config doesn't exist, create memory for it */	if (!pContext->pConfig) {#ifndef USERLAND_TEST		status = NdisAllocateMemory(&(pContext->pConfig), 			sizeof(PGPnetKernelConfig),			0, 			HighestAcceptableAddress);			if (status != NDIS_STATUS_SUCCESS)				return kPGPError_OutOfMemory;#else		pContext->pConfig = malloc(sizeof(PGPnetKernelConfig));		if (!pContext->pConfig)			return kPGPError_OutOfMemory;#endif /* USERLAND_TEST */	}	/* clear out anything there */	pgpClearMemory(pContext->pConfig, sizeof(PGPnetKernelConfig));	/* copy configuration values */	pContext->pConfig->bPGPnetEnabled = pConfig->bPGPnetEnabled;	pContext->pConfig->bAllowUnconfigHost = pConfig->bAllowUnconfigHost;	pContext->pConfig->bAttemptUnconfigHost = pConfig->bAttemptUnconfigHost;	DBG_LEAVE(kPGPError_NoErr);	return kPGPError_NoErr;}

/* {{{ mysqlnd_native_auth_get_auth_data */static voidmysqlnd_caching_sha2_handle_server_response(struct st_mysqlnd_authentication_plugin *self,		MYSQLND_CONN_DATA * conn,		const zend_uchar * auth_plugin_data, const size_t auth_plugin_data_len,		const char * const passwd,		const size_t passwd_len){	DBG_ENTER("mysqlnd_caching_sha2_handle_server_response");	MYSQLND_PACKET_CACHED_SHA2_RESULT result_packet;	conn->payload_decoder_factory->m.init_cached_sha2_result_packet(&result_packet);	if (FAIL == PACKET_READ(conn, &result_packet)) {		DBG_VOID_RETURN;	}	switch (result_packet.response_code) {		case 3:			DBG_INF("fast path succeeded");			DBG_VOID_RETURN;		case 4:			if (conn->vio->data->ssl || conn->unix_socket.s) {				DBG_INF("fast path failed, doing full auth via SSL");				result_packet.password = (zend_uchar *)passwd;				result_packet.password_len = passwd_len + 1;				PACKET_WRITE(conn, &result_packet);			} else {				DBG_INF("fast path failed, doing full auth without SSL");				result_packet.password_len = mysqlnd_caching_sha2_get_and_use_key(conn, auth_plugin_data, auth_plugin_data_len, &result_packet.password, passwd, passwd_len);				PACKET_WRITE(conn, &result_packet);				efree(result_packet.password);			}			DBG_VOID_RETURN;		case 2:			// The server tried to send a key, which we didn't expect			// fall-through		default:			php_error_docref(NULL, E_WARNING, "Unexpected server response while doing caching_sha2 auth: %i", result_packet.response_code);	}	DBG_VOID_RETURN;}

/* {{{ mysqlnd_switch_to_ssl_if_needed */static enum_func_statusmysqlnd_switch_to_ssl_if_needed(MYSQLND_CONN_DATA * conn,								unsigned int charset_no,								size_t server_capabilities,								const MYSQLND_SESSION_OPTIONS * const session_options,								zend_ulong mysql_flags){	enum_func_status ret = FAIL;	const MYSQLND_CHARSET * charset;	DBG_ENTER("mysqlnd_switch_to_ssl_if_needed");	if (session_options->charset_name && (charset = mysqlnd_find_charset_name(session_options->charset_name))) {		charset_no	= charset->nr;	}	{		size_t client_capabilities = mysql_flags;		ret = conn->run_command(COM_ENABLE_SSL, conn, client_capabilities, server_capabilities, charset_no);	}	DBG_RETURN(ret);}

//-------------------------------------------------//删除链表，释放链表空间//-------------------------------------------------INT32 CInvHead::DelList(){	DBG_PRINT(("进入DelList函数"));	DBG_ENTER("CInvHead::DelList");	CInvDet *p = pHead;	CInvDet *s;		while (p)	{		DBG_PRINT(("delete CInvDet: DP_NO = %s!", p->m_spbm.c_str()));		s = p;		p = p->pNext;		//delete s;		s->FreeInvDet();//释放该节点所占空间	}	pHead = NULL;	pEnd = NULL;		DBG_PRINT(("退出DelList函数"));    DBG_RETURN(SUCCESS);}