exconvrt.c

linux-2.4.29操作系统的源码

				string[k] = (u8) (ACPI_ASCII_ZERO + remainder);
				k++;
			}
		}
		break;


	case 16:

		/* Copy the integer to the buffer */

		for (i = 0, j = ((length * 2) -1); i < (length * 2); i++, j--) {

			hex_digit = acpi_ut_hex_to_ascii_char (integer, (j * 4));
			if (hex_digit != ACPI_ASCII_ZERO) {
				leading_zero = FALSE;
			}

			if (!leading_zero) {
				string[k] = (u8) hex_digit;
				k++;
			}
		}
		break;


	default:
		break;
	}

	/*
	 * Since leading zeros are supressed, we must check for the case where
	 * the integer equals 0
	 *
	 * Finally, null terminate the string and return the length
	 */
	if (!k) {
		string [0] = ACPI_ASCII_ZERO;
		k = 1;
	}

	string [k] = 0;
	return (k);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_convert_to_string
 *
 * PARAMETERS:  obj_desc        - Object to be converted.  Must be an
 *                                  Integer, Buffer, or String
 *              result_desc     - Where the string object is returned
 *              Base            - 10 or 16
 *              max_length      - Max length of the returned string
 *              walk_state      - Current method state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Convert an ACPI Object to a string
 *
 ******************************************************************************/

acpi_status
acpi_ex_convert_to_string (
	union acpi_operand_object       *obj_desc,
	union acpi_operand_object       **result_desc,
	u32                             base,
	u32                             max_length,
	struct acpi_walk_state          *walk_state)
{
	union acpi_operand_object       *ret_desc;
	u8                              *new_buf;
	u8                              *pointer;
	u32                             string_length;
	u32                             i;


	ACPI_FUNCTION_TRACE_PTR ("ex_convert_to_string", obj_desc);


	switch (ACPI_GET_OBJECT_TYPE (obj_desc)) {
	case ACPI_TYPE_STRING:

		if (max_length >= obj_desc->string.length) {
			*result_desc = obj_desc;
			return_ACPI_STATUS (AE_OK);
		}
		else {
			/* Must copy the string first and then truncate it */

			return_ACPI_STATUS (AE_NOT_IMPLEMENTED);
		}


	case ACPI_TYPE_INTEGER:

		string_length = acpi_gbl_integer_byte_width * 2;
		if (base == 10) {
			string_length = ACPI_MAX_DECIMAL_DIGITS;
		}

		/*
		 * Create a new String
		 */
		ret_desc = acpi_ut_create_internal_object (ACPI_TYPE_STRING);
		if (!ret_desc) {
			return_ACPI_STATUS (AE_NO_MEMORY);
		}

		/* Need enough space for one ASCII integer plus null terminator */

		new_buf = ACPI_MEM_CALLOCATE ((acpi_size) string_length + 1);
		if (!new_buf) {
			ACPI_REPORT_ERROR
				(("ex_convert_to_string: Buffer allocation failure\n"));
			acpi_ut_remove_reference (ret_desc);
			return_ACPI_STATUS (AE_NO_MEMORY);
		}

		/* Convert */

		i = acpi_ex_convert_to_ascii (obj_desc->integer.value, base, new_buf, sizeof (acpi_integer));

		/* Null terminate at the correct place */

		if (max_length < i) {
			new_buf[max_length] = 0;
			ret_desc->string.length = max_length;
		}
		else {
			new_buf [i] = 0;
			ret_desc->string.length = i;
		}

		ret_desc->buffer.pointer = new_buf;
		break;


	case ACPI_TYPE_BUFFER:

		/* Find the string length */

		pointer = obj_desc->buffer.pointer;
		for (string_length = 0; string_length < obj_desc->buffer.length; string_length++) {
			/* Exit on null terminator */

			if (!pointer[string_length]) {
				break;
			}
		}

		if (max_length > ACPI_MAX_STRING_CONVERSION) {
			if (string_length > ACPI_MAX_STRING_CONVERSION) {
				return_ACPI_STATUS (AE_AML_STRING_LIMIT);
			}
		}

		/*
		 * Create a new string object
		 */
		ret_desc = acpi_ut_create_internal_object (ACPI_TYPE_STRING);
		if (!ret_desc) {
			return_ACPI_STATUS (AE_NO_MEMORY);
		}

		/* String length is the lesser of the Max or the actual length */

		if (max_length < string_length) {
			string_length = max_length;
		}

		new_buf = ACPI_MEM_CALLOCATE ((acpi_size) string_length + 1);
		if (!new_buf) {
			ACPI_REPORT_ERROR
				(("ex_convert_to_string: Buffer allocation failure\n"));
			acpi_ut_remove_reference (ret_desc);
			return_ACPI_STATUS (AE_NO_MEMORY);
		}

		/* Copy the appropriate number of buffer characters */

		ACPI_MEMCPY (new_buf, pointer, string_length);

		/* Null terminate */

		new_buf [string_length] = 0;
		ret_desc->buffer.pointer = new_buf;
		ret_desc->string.length = string_length;
		break;


	default:
		return_ACPI_STATUS (AE_TYPE);
	}

	/*
	 * If we are about to overwrite the original object on the operand stack,
	 * we must remove a reference on the original object because we are
	 * essentially removing it from the stack.
	 */
	if (*result_desc == obj_desc) {
		if (walk_state->opcode != AML_STORE_OP) {
			acpi_ut_remove_reference (obj_desc);
		}
	}

	*result_desc = ret_desc;
	return_ACPI_STATUS (AE_OK);
}


/*******************************************************************************
 *
 * FUNCTION:    acpi_ex_convert_to_target_type
 *
 * PARAMETERS:  destination_type    - Current type of the destination
 *              source_desc         - Source object to be converted.
 *              result_desc         - Where the converted object is returned
 *              walk_state          - Current method state
 *
 * RETURN:      Status
 *
 * DESCRIPTION: Implements "implicit conversion" rules for storing an object.
 *
 ******************************************************************************/

acpi_status
acpi_ex_convert_to_target_type (
	acpi_object_type                destination_type,
	union acpi_operand_object       *source_desc,
	union acpi_operand_object       **result_desc,
	struct acpi_walk_state          *walk_state)
{
	acpi_status                     status = AE_OK;


	ACPI_FUNCTION_TRACE ("ex_convert_to_target_type");


	/* Default behavior */

	*result_desc = source_desc;

	/*
	 * If required by the target,
	 * perform implicit conversion on the source before we store it.
	 */
	switch (GET_CURRENT_ARG_TYPE (walk_state->op_info->runtime_args)) {
	case ARGI_SIMPLE_TARGET:
	case ARGI_FIXED_TARGET:
	case ARGI_INTEGER_REF:      /* Handles Increment, Decrement cases */

		switch (destination_type) {
		case ACPI_TYPE_LOCAL_REGION_FIELD:
			/*
			 * Named field can always handle conversions
			 */
			break;

		default:
			/* No conversion allowed for these types */

			if (destination_type != ACPI_GET_OBJECT_TYPE (source_desc)) {
				ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
					"Explicit operator, will store (%s) over existing type (%s)\n",
					acpi_ut_get_object_type_name (source_desc),
					acpi_ut_get_type_name (destination_type)));
				status = AE_TYPE;
			}
		}
		break;


	case ARGI_TARGETREF:

		switch (destination_type) {
		case ACPI_TYPE_INTEGER:
		case ACPI_TYPE_BUFFER_FIELD:
		case ACPI_TYPE_LOCAL_BANK_FIELD:
		case ACPI_TYPE_LOCAL_INDEX_FIELD:
			/*
			 * These types require an Integer operand.  We can convert
			 * a Buffer or a String to an Integer if necessary.
			 */
			status = acpi_ex_convert_to_integer (source_desc, result_desc, walk_state);
			break;


		case ACPI_TYPE_STRING:

			/*
			 * The operand must be a String.  We can convert an
			 * Integer or Buffer if necessary
			 */
			status = acpi_ex_convert_to_string (source_desc, result_desc, 16, ACPI_UINT32_MAX, walk_state);
			break;


		case ACPI_TYPE_BUFFER:

			/*
			 * The operand must be a Buffer.  We can convert an
			 * Integer or String if necessary
			 */
			status = acpi_ex_convert_to_buffer (source_desc, result_desc, walk_state);
			break;


		default:
			ACPI_REPORT_ERROR (("Bad destination type during conversion: %X\n",
				destination_type));
			status = AE_AML_INTERNAL;
			break;
		}
		break;


	case ARGI_REFERENCE:
		/*
		 * create_xxxx_field cases - we are storing the field object into the name
		 */
		break;


	default:
		ACPI_DEBUG_PRINT ((ACPI_DB_ERROR,
			"Unknown Target type ID 0x%X Op %s dest_type %s\n",
			GET_CURRENT_ARG_TYPE (walk_state->op_info->runtime_args),
			walk_state->op_info->name, acpi_ut_get_type_name (destination_type)));

		ACPI_REPORT_ERROR (("Bad Target Type (ARGI): %X\n",
			GET_CURRENT_ARG_TYPE (walk_state->op_info->runtime_args)))
		status = AE_AML_INTERNAL;
	}

	/*
	 * Source-to-Target conversion semantics:
	 *
	 * If conversion to the target type cannot be performed, then simply
	 * overwrite the target with the new object and type.
	 */
	if (status == AE_TYPE) {
		status = AE_OK;
	}

	return_ACPI_STATUS (status);
}