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

/* * This function changes the size of a block of memory that was previously allocated with malloc(). */void * GMM001_realloc (uint32_t size, void * MemPtr){  void * MemPtr1 = NULL;  FUNCTION_ENTRY(GID_GMM001, (uint32_t)GMM001_FUNCTION_ENTRY);/*<<<DD_GMM001_API_3_1>>>*/     if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank1_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank1_Start + LENGTH1)))  {	  MemPtr1 = LMM001_realloc(&GMM001_handle0, MemPtr, size);  }/*<<<DD_GMM001_API_3_2>>>*/     else if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank2_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank2_Start + LENGTH2)))  { 	  MemPtr1 = LMM001_realloc(&GMM001_handle1, MemPtr, size);  }/*<<<DD_GMM001_API_3_3>>>*/     else if (((uint32_t)MemPtr >= (uint32_t)Heap_Bank3_Start) && ((uint32_t)MemPtr <= ((uint32_t)Heap_Bank3_Start + LENGTH3)))  { 	  MemPtr1 = LMM001_realloc(&GMM001_handle2, MemPtr, size);  }  FUNCTION_EXIT(GID_GMM001, (uint32_t)GMM001_FUNCTION_EXIT);  return MemPtr1;}

u32acpi_ns_get_pathname_length (	acpi_namespace_node     *node){	u32                     size;	acpi_namespace_node     *next_node;	FUNCTION_ENTRY ();	/*	 * Compute length of pathname as 5 * number of name segments.	 * Go back up the parent tree to the root	 */	for (size = 0, next_node = node;		  acpi_ns_get_parent_object (next_node);		  next_node = acpi_ns_get_parent_object (next_node)) {		size += PATH_SEGMENT_LENGTH;	}	/* Special case for size still 0 - no parent for "special" nodes */	if (!size) {		size = PATH_SEGMENT_LENGTH;	}	return (size + 1);}

acpi_namespace_node *acpi_ns_map_handle_to_node (	acpi_handle             handle){	FUNCTION_ENTRY ();	/*	 * Simple implementation for now;	 * TBD: [Future] Real integer handles allow for more verification	 * and keep all pointers within this subsystem!	 */	if (!handle) {		return (NULL);	}	if (handle == ACPI_ROOT_OBJECT) {		return (acpi_gbl_root_node);	}	/* We can at least attempt to verify the handle */	if (!VALID_DESCRIPTOR_TYPE (handle, ACPI_DESC_TYPE_NAMED)) {		return (NULL);	}	return ((acpi_namespace_node *) handle);}

voidacpi_rs_dump_io (	acpi_resource_data      *data){	acpi_resource_io        *io_data = (acpi_resource_io *) data;	FUNCTION_ENTRY ();	acpi_os_printf ("Io Resource/n");	acpi_os_printf ("  %d bit decode/n",			 DECODE_16 == io_data->io_decode ? 16 : 10);	acpi_os_printf ("  Range minimum base: %08X/n",			 io_data->min_base_address);	acpi_os_printf ("  Range maximum base: %08X/n",			 io_data->max_base_address);	acpi_os_printf ("  Alignment: %08X/n",			 io_data->alignment);	acpi_os_printf ("  Range Length: %08X/n",			 io_data->range_length);	return;}

voidacpi_rs_dump_fixed_memory32 (	acpi_resource_data          *data){	acpi_resource_fixed_mem32   *fixed_memory32_data = (acpi_resource_fixed_mem32 *) data;	FUNCTION_ENTRY ();	acpi_os_printf ("32-Bit Fixed Location Memory Range Resource/n");	acpi_os_printf ("  Read%s/n",			 READ_WRITE_MEMORY ==			 fixed_memory32_data->read_write_attribute ?			 "/Write" : " Only");	acpi_os_printf ("  Range base address: %08X/n",			 fixed_memory32_data->range_base_address);	acpi_os_printf ("  Range length: %08X/n",			 fixed_memory32_data->range_length);	return;}

GtkMngView *gtk_mng_view_new (void){    FUNCTION_ENTRY();    FUNCTION_EXIT();  return GTK_MNG_VIEW (g_object_new(GTK_MNG_VIEW_TYPE, NULL));}

UINT32AcpiNsGetPathnameLength (    ACPI_NAMESPACE_NODE     *Node){    UINT32                  Size;    ACPI_NAMESPACE_NODE     *NextNode;    FUNCTION_ENTRY ();    /*     * Compute length of pathname as 5 * number of name segments.     * Go back up the parent tree to the root     */    for (Size = 0, NextNode = Node;          AcpiNsGetParentObject (NextNode);          NextNode = AcpiNsGetParentObject (NextNode))    {        Size += PATH_SEGMENT_LENGTH;    }    /* Special case for size still 0 - no parent for "special" nodes */    if (!Size)    {        Size = PATH_SEGMENT_LENGTH;    }    return (Size + 1);}

	void DataPointObserver::processDataPointUpdate( unsigned long pkey, 		boost::shared_ptr<TA_Base_Bus::DpDynamicSyncUpdate> updateDetails )	{		//		// callback from one of the DataPoint supposedly being assigned to this observer		//		std::stringstream ss;		ss << "processDataPointUpdate: Observer ID "  		   << m_observerID << "--> received an update from data point " << pkey;		FUNCTION_ENTRY (ss.str().c_str() );		// only proceed if the specified pkey matches with the pkey of the		// data point assigned to this observer		DataPoint * existingDataPoint = 0;		existingDataPoint = findExistingDataPoint ( pkey );		// if found one		if ( NULL != existingDataPoint )		{			//convet it from cpp to corba first.			TA_Base_Bus::DataPointCorbaTypes::UDynamicSyncUpdate dpUpdate;			convertDynamicSyncUpdate(*updateDetails, dpUpdate);			saveDataPointUpdateDetails ( pkey, dpUpdate );		}		// else do nothing		FUNCTION_EXIT;	}

u32acpi_tb_get_table_count (	RSDP_DESCRIPTOR         *RSDP,	acpi_table_header       *RSDT){	u32                     pointer_size;	FUNCTION_ENTRY ();#ifndef _IA64	if (RSDP->revision < 2) {		pointer_size = sizeof (u32);	}	else#endif	{		pointer_size = sizeof (u64);	}	/*	 * Determine the number of tables pointed to by the RSDT/XSDT.	 * This is defined by the ACPI Specification to be the number of	 * pointers contained within the RSDT/XSDT.  The size of the pointers	 * is architecture-dependent.	 */	return ((RSDT->length - sizeof (acpi_table_header)) / pointer_size);}

SQLRETURN SRVR_STMT_HDL::Prepare(const SQLValue_def *inSqlString, short inStmtType, short inHoldability,								 long inQueryTimeout,bool isISUD){	FUNCTION_ENTRY("SRVR_STMT_HDL::Prepare",(""));	DEBUG_OUT(DEBUG_LEVEL_ENTRY,("  inSqlString='%s'",		CLI_SQL_VALUE_STR(inSqlString)));	DEBUG_OUT(DEBUG_LEVEL_ENTRY,("  inStmtType=%s, inHoldability=%d, inQueryTimeout=%ld, isISUD=%d",		CliDebugStatementType(inStmtType),		inHoldability,		inQueryTimeout,isISUD));	SQLRETURN rc;	size_t	len;	this->isISUD = isISUD;	if (isReadFromModule)	// Already SMD label is found		CLI_DEBUG_RETURN_SQL(SQL_SUCCESS);	// cleanup all memory allocated in the previous operations	cleanupAll();	sqlString.dataCharset = inSqlString->dataCharset;	sqlString.dataType = inSqlString->dataType;	MEMORY_ALLOC_ARRAY(sqlString.dataValue._buffer,unsigned char,inSqlString->dataValue._length+1);	sqlString.dataValue._length = inSqlString->dataValue._length+1;	strncpy((char *)sqlString.dataValue._buffer, (const char *)inSqlString->dataValue._buffer, inSqlString->dataValue._length);	sqlString.dataValue._buffer[inSqlString->dataValue._length] = '/0';	stmtType = inStmtType;	holdability = inHoldability;	CLI_DEBUG_RETURN_SQL(PREPARE(this));}

    void DatabaseFactory::delDatabase( IDatabase* pDatabase )    {        FUNCTION_ENTRY("delDatabase(IDatabase*)");        if ( NULL == pDatabase )        {            LOG(SourceInfo, DebugUtil::GenericLog, DebugUtil::DebugWarn, "Invalid input parameter that IDatabase is NULL pointer");            return;        }        bool bExist = false;        {            ThreadGuard guard( m_getDatabaseLock );            // set up iterators to step through the database map.            ThreadMap::iterator threadIter (m_databaseMap.begin());            ThreadMap::iterator threadIterEnd (m_databaseMap.end());            // step through member map            while (threadIter != threadIterEnd)            {                ConnectionMap::iterator iter (threadIter->second.begin());                ConnectionMap::iterator iterEnd (threadIter->second.end());                while (iter != iterEnd)                {                    if (iter->second == pDatabase)                    {                        threadIter->second.erase( iter );                        if ( threadIter->second.empty() )                        {                            m_databaseMap.erase( threadIter );                        }                        bExist = true;                        break;                    }                                   iter++;                }                if ( bExist )                {                    break;                }                threadIter++;            }        }        if ( bExist )        {            delete pDatabase;            pDatabase = NULL;        }        else        {            TA_THROW(DatabaseException("Unable to find the IDatabase"));        }        FUNCTION_EXIT;    }

//venu changed dialogueId and stmtId from int to long for 64 bitJNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_SQLMXStatement_cancel(JNIEnv *jenv, jobject jobj, jstring server, jlong dialogueId, jlong stmtId){    FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_SQLMXStatement_cancel",("..."));    ExceptionStruct				exception_;    ERROR_DESC_LIST_def			sqlWarning;    odbc_SQLSvc_CancelStatement_sme_(NULL, NULL, &exception_,                                     dialogueId,                                     stmtId,                                     &sqlWarning);    // Ignore setting warning since the input is jclass and not jobject    switch (exception_.exception_nr)    {    case CEE_SUCCESS:        break;    case odbc_SQLSvc_CancelStatement_SQLError_exn_:        throwSQLException(jenv, &exception_.u.SQLError);        break;    case odbc_SQLSvc_CancelStatement_ParamError_exn_:        throwSQLException(jenv, PROGRAMMING_ERROR, exception_.u.ParamError.ParamDesc, "HY000");        break;    case odbc_SQLSvc_CancelStatement_SQLInvalidHandle_exn_:        throwSQLException(jenv, INVALID_HANDLE_ERROR, NULL, "HY000", exception_.u.SQLInvalidHandle.sqlcode);        break;    case odbc_SQLSvc_CancelStatement_InvalidConnection_exn_:    default:        // TFDS - This exceptions should not happen        throwSQLException(jenv, PROGRAMMING_ERROR, NULL, "HY000", exception_.exception_nr);        break;    }    FUNCTION_RETURN_VOID((NULL));}

static voidgtk_mng_view_realize (GtkWidget * widget){    FUNCTION_ENTRY();  GdkWindowAttr attributes;  gint attributes_mask;  g_return_if_fail (IS_GTK_MNG_VIEW (widget));  GTK_WIDGET_SET_FLAGS (widget, GTK_REALIZED);  attributes.window_type = GDK_WINDOW_CHILD;  attributes.x = widget->allocation.x;  attributes.y = widget->allocation.y;  attributes.width = widget->allocation.width;  attributes.height = widget->allocation.height;  attributes.wclass = GDK_INPUT_OUTPUT;  attributes.visual = gtk_widget_get_visual (widget);  attributes.colormap = gtk_widget_get_colormap (widget);  attributes.event_mask = gtk_widget_get_events (widget);  attributes.event_mask |= GDK_EXPOSURE_MASK;  attributes_mask = GDK_WA_X | GDK_WA_Y | GDK_WA_VISUAL | GDK_WA_COLORMAP;  widget->window = gdk_window_new (gtk_widget_get_parent_window (widget),			    	   &attributes, attributes_mask);  gdk_window_set_user_data (widget->window, widget);  widget->style = gtk_style_attach (widget->style, widget->window);  gtk_style_set_background (widget->style, widget->window, GTK_STATE_NORMAL);}

voidAcpiHwDisableGpe (    UINT32                  GpeNumber){    UINT32                  InByte;    UINT32                  RegisterIndex;    UINT32                  BitMask;    FUNCTION_ENTRY ();    /*     * Translate GPE number to index into global registers array.     */    RegisterIndex = AcpiGbl_GpeValid[GpeNumber];    /*     * Figure out the bit offset for this GPE within the target register.     */    BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)];    /*     * Read the current value of the register, clear the appropriate bit,     * and write out the new register value to disable the GPE.     */    InByte = 0;    AcpiOsReadPort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr, &InByte, 8);    AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].EnableAddr,                (InByte & ~BitMask), 8);}

static mng_boolmng_close_stream_callback (mng_handle mng_h){    FUNCTION_ENTRY();    FUNCTION_EXIT();  return MNG_TRUE;}

voidAcpiHwClearGpe (    UINT32                  GpeNumber){    UINT32                  RegisterIndex;    UINT32                  BitMask;    FUNCTION_ENTRY ();    /*     * Translate GPE number to index into global registers array.     */    RegisterIndex = AcpiGbl_GpeValid[GpeNumber];    /*     * Figure out the bit offset for this GPE within the target register.     */    BitMask = AcpiGbl_DecodeTo8bit [MOD_8 (GpeNumber)];    /*     * Write a one to the appropriate bit in the status register to     * clear this GPE.     */    AcpiOsWritePort (AcpiGbl_GpeRegisters[RegisterIndex].StatusAddr, BitMask, 8);}

static mng_boolmng_read_data_callback (mng_handle mng_h,			mng_ptr buffer,			mng_uint32 bytes_requested,        		mng_uint32 * bytes_read){    FUNCTION_ENTRY();    *bytes_read = 0;    return MNG_FALSE;  guint available_mng_food;  GtkMngView * mng_view = GTK_MNG_VIEW (mng_get_userdata (mng_h));  available_mng_food = mng_view->bytes_to_eat - mng_view->bytes_eaten;  if (available_mng_food > 0 && mng_view->mng_food != NULL)    {      * bytes_read = (mng_uint32) MIN ((mng_uint32) available_mng_food, bytes_requested);      memcpy (buffer, mng_view->mng_food + mng_view->bytes_eaten, * bytes_read);      mng_view->bytes_eaten += * bytes_read;      FUNCTION_EXIT();      return MNG_TRUE;    }  else {      FUNCTION_EXIT();    return MNG_FALSE;  }}

/** Class:     org_trafodion_jdbc_t2_T2Driver* Method:    setCharsetEncodingOverride* Signature: (I)Ljava/lang/String;* Note: This function is a generic implementation to allow setting the*       char set override encoding for the given charset (currently only the ISO88591*       column is allowed to be overriden)*/JNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_T2Driver_setCharsetEncodingOverride(JNIEnv *jenv, jclass jcls,																					jint charset, jstring encodingOverride){	FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_T2Driver_setCharsetEncodingOverride",		("charset=%ld, encodingOverride=%s",charset, DebugJString(jenv,encodingOverride)));	//Added for connect/disconnect impro.		 if (srvrGlobal == NULL)		 MEMORY_ALLOC_PERM(srvrGlobal,SRVR_GLOBAL_Def)	for (int idx=0; idx<gJNICache.totalCharsets; idx++)		if (charset == gJNICache.charsetInfo[idx].charset)		{			const char *nEncodingOverride = JNI_GetStringUTFChars(jenv,encodingOverride, NULL);			if (strcmp(nEncodingOverride,defaultEncodingOption) == 0)			{				gJNICache.charsetInfo[idx].useDefaultEncoding = TRUE;			}			else			{				gJNICache.charsetInfo[idx].useDefaultEncoding = FALSE;			}			JNI_ReleaseStringUTFChars(jenv,encodingOverride, nEncodingOverride);		}		FUNCTION_RETURN_VOID((NULL));}

bool ParseBAND ( char *text, const sOptionTableInfo &info, sRejectOptionRMB *option ){    FUNCTION_ENTRY ( NULL, "ParseBAND", true );    REJECT_OPTION_E type = OPTION_UNKNOWN;    while ( isspace ( *text )) text++;    if ( strncmp ( text, "BLIND", 5 ) == 0 ) {        type = OPTION_BLIND;        text += 5;    } else if ( strncmp ( text, "SAFE", 5 ) == 0 ) {        type = OPTION_SAFE;        text += 4;    } else {        goto bad_option;    }    if ( isspace ( *text )) {        bool retVal = ParseGeneric ( text, info, option );        option->Banded = true;        option->Info   = FindByType ( type );        return retVal;    }bad_option:    ParseError ( "Invalid BAND option." );    return false;}

/** Class:     org_trafodion_jdbc_t2_T2Driver* Method:    checkLibraryVersion* Signature: (Ljava/lang/String;)V*/JNIEXPORT void JNICALL Java_org_trafodion_jdbc_t2_T2Driver_checkLibraryVersion(JNIEnv *jenv, jclass jcls,																			 jstring javaVproc){#ifdef NSK_PLATFORM	// Linux port - ToDo txn related		int cliret = client_initialization();//by venu for TSLX		if (cliret != 1)//client init return 1 on success		{				DEBUG_OUT(DEBUG_LEVEL_TXN,("TSLX initialization failed %d", cliret));		}		DEBUG_OUT(DEBUG_LEVEL_TXN,("TSLX Initialization done"));#endif	//Added for R3.0 Transaction issue sol. 10-100430-9906	FUNCTION_ENTRY("Java_org_trafodion_jdbc_t2_T2Driver_checkLibraryVersion",("javaVproc=%s",		DebugJString(jenv,javaVproc)));	// Set the TMLIB cleanup 	setTM_enable_cleanup();#ifdef NSK_PLATFORM		// Linux port  	short status = tmfInit();  	DEBUG_OUT(DEBUG_LEVEL_TXN,("tmfInit() returned %d", status));  	if (status != 0)  	{  		throwTransactionException(jenv, status);  		FUNCTION_RETURN_VOID(("status(%d) is non-zero",status));	}#endif//End	if (javaVproc && !driverVersionChecked)	{		const char *java_vproc_str = JNI_GetStringUTFChars(jenv,javaVproc, NULL);		if (java_vproc_str)		{			if (strcmp(java_vproc_str,driverVproc)!=0)			{				printf("JDBC Library Version Error - Jar: %s Jni: %s/n",					java_vproc_str,driverVproc);				abort();			}			JNI_ReleaseStringUTFChars(jenv,javaVproc, java_vproc_str);			driverVersionChecked = true;		}	}	FUNCTION_RETURN_VOID((NULL));}

voidacpi_rs_dump_memory32 (	acpi_resource_data      *data){	acpi_resource_mem32     *memory32_data = (acpi_resource_mem32 *) data;	FUNCTION_ENTRY ();	acpi_os_printf ("32-Bit Memory Range Resource/n");	acpi_os_printf ("  Read%s/n",			 READ_WRITE_MEMORY ==			 memory32_data->read_write_attribute ?			 "/Write" : " only");	acpi_os_printf ("  Range minimum base: %08X/n",			 memory32_data->min_base_address);	acpi_os_printf ("  Range maximum base: %08X/n",			 memory32_data->max_base_address);	acpi_os_printf ("  Alignment: %08X/n",			 memory32_data->alignment);	acpi_os_printf ("  Range length: %08X/n",			 memory32_data->range_length);	return;}

ACPI_DEBUG_MEM_BLOCK *AcpiUtSearchAllocList (    UINT32                  ListId,    void                    *Address){    ACPI_DEBUG_MEM_BLOCK    *Element;    FUNCTION_ENTRY ();    if (ListId > ACPI_MEM_LIST_MAX)    {        return (NULL);    }    Element = AcpiGbl_MemoryLists[ListId].ListHead;    /* Search for the address. */    while (Element)    {        if (Element == Address)        {            return (Element);        }        Element = Element->Next;    }    return (NULL);}

voidacpi_rs_dump_irq (	acpi_resource_data      *data){	acpi_resource_irq       *irq_data = (acpi_resource_irq *) data;	u8                      index = 0;	FUNCTION_ENTRY ();	acpi_os_printf ("IRQ Resource/n");	acpi_os_printf ("  %s Triggered/n",			 LEVEL_SENSITIVE == irq_data->edge_level ? "Level" : "Edge");	acpi_os_printf ("  Active %s/n",			 ACTIVE_LOW == irq_data->active_high_low ? "Low" : "High");	acpi_os_printf ("  %s/n",			 SHARED == irq_data->shared_exclusive ? "Shared" : "Exclusive");	acpi_os_printf ("  %X Interrupts ( ", irq_data->number_of_interrupts);	for (index = 0; index < irq_data->number_of_interrupts; index++) {		acpi_os_printf ("%X ", irq_data->interrupts[index]);	}	acpi_os_printf (")/n");	return;}

static mng_ptrmng_malloc_callback (mng_size_t how_many){    FUNCTION_ENTRY();    FUNCTION_EXIT();  return (mng_ptr) g_new0 (gchar, how_many);}

CCFDRequestHelper::~CCFDRequestHelper(){	FUNCTION_ENTRY("~CDataBuffer");	FUNCTION_EXIT;}

static gbooleangtk_mng_view_expose (GtkWidget * widget, GdkEventExpose * event){    FUNCTION_ENTRY();  g_return_val_if_fail (IS_GTK_MNG_VIEW (widget), FALSE);  g_return_val_if_fail (event != NULL, FALSE);  if (GTK_WIDGET_REALIZED (widget))    {      GdkRectangle dummy;      GdkRectangle rectangle;      GtkMngView * mng_view;      mng_view = GTK_MNG_VIEW (widget);      dummy.x = dummy.y = 0;      dummy.width = mng_view->width;      dummy.height = mng_view->height;      if (gdk_rectangle_intersect (&dummy, &event->area, &rectangle))        gtk_mng_view_paint (mng_view, &rectangle);      mng_display_resume(mng_view->MNG_handle);    }  FUNCTION_EXIT();  return FALSE;}

acpi_namespace_node *acpi_ns_get_parent_object (	acpi_namespace_node     *node){	FUNCTION_ENTRY ();	if (!node) {		return (NULL);	}	/*	 * Walk to the end of this peer list.	 * The last entry is marked with a flag and the peer	 * pointer is really a pointer back to the parent.	 * This saves putting a parent back pointer in each and	 * every named object!	 */	while (!(node->flags & ANOBJ_END_OF_PEER_LIST)) {		node = node->peer;	}	return (node->peer);}

voidacpi_hw_enable_gpe_for_wakeup (	u32                     gpe_number){	u32                     register_index;	u32                     bit_mask;	FUNCTION_ENTRY ();	/*	 * Translate GPE number to index into global registers array.	 */	register_index = acpi_gbl_gpe_valid[gpe_number];	/*	 * Figure out the bit offset for this GPE within the target register.	 */	bit_mask = acpi_gbl_decode_to8bit [MOD_8 (gpe_number)];	/*	 * Set the bit so we will not disable this when sleeping	 */	acpi_gbl_gpe_registers[register_index].wake_enable |= bit_mask;}