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;
}

u32
acpi_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);
}

void
acpi_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;
}

void
acpi_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));
}

UINT32
AcpiNsGetPathnameLength (
    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;
	}

u32
acpi_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 bit
JNIEXPORT 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 void
gtk_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);
}

void
AcpiHwDisableGpe (
    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_bool
mng_close_stream_callback (mng_handle mng_h)
{
    FUNCTION_ENTRY();
    FUNCTION_EXIT();
  return MNG_TRUE;
}