utstrtoul64.c File Reference

#include "acpi.h"
#include "accommon.h"

Include dependency graph for utstrtoul64.c:

Go to the source code of this file.

Macros
#define	_COMPONENT   ACPI_UTILITIES

Functions
ACPI_STATUS	AcpiUtStrtoul64 (char *String, UINT64 *ReturnValue)
UINT64	AcpiUtImplicitStrtoul64 (char *String)
UINT64	AcpiUtExplicitStrtoul64 (char *String)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_UTILITIES

Definition at line 48 of file utstrtoul64.c.

Function Documentation

AcpiUtExplicitStrtoul64()

UINT64 AcpiUtExplicitStrtoul64

(

char *

String

)

Definition at line 347 of file utstrtoul64.c.

{
    UINT64                  ConvertedInteger = 0;
    UINT32                  Base = 10;          /* Default is decimal */
 
 
    ACPI_FUNCTION_TRACE_STR (UtExplicitStrtoul64, String);
 
 
    if (!AcpiUtRemoveWhitespace (&String))
    {
        return_VALUE (0);
    }
 
    /*
     * Only Hex and Decimal are supported, as per the ACPI specification.
     * A "0x" prefix indicates hex; otherwise decimal is assumed.
     */
    if (AcpiUtDetectHexPrefix (&String))
    {
        Base = 16;
    }
 
    if (!AcpiUtRemoveLeadingZeros (&String))
    {
        return_VALUE (0);
    }
 
    /*
     * Ignore overflow as per the ACPI specification. This is implemented by
     * ignoring the return status from the conversion functions called below.
     * On overflow, the input string is simply truncated.
     */
    switch (Base)
    {
    case 10:
    default:
        AcpiUtConvertDecimalString (String, &ConvertedInteger);
        break;
 
    case 16:
        AcpiUtConvertHexString (String, &ConvertedInteger);
        break;
    }
 
    return_VALUE (ConvertedInteger);
}

Referenced by AcpiExConvertToInteger().

AcpiUtImplicitStrtoul64()

UINT64 AcpiUtImplicitStrtoul64

(

char *

String

)

Definition at line 259 of file utstrtoul64.c.

{
    UINT64                  ConvertedInteger = 0;
 
 
    ACPI_FUNCTION_TRACE_STR (UtImplicitStrtoul64, String);
 
 
    if (!AcpiUtRemoveWhitespace (&String))
    {
        return_VALUE (0);
    }
 
    /*
     * Per the ACPI specification, only hexadecimal is supported for
     * implicit conversions, and the "0x" prefix is "not allowed".
     * However, allow a "0x" prefix as an ACPI extension.
     */
    AcpiUtRemoveHexPrefix (&String);
 
    if (!AcpiUtRemoveLeadingZeros (&String))
    {
        return_VALUE (0);
    }
 
    /*
     * Ignore overflow as per the ACPI specification. This is implemented by
     * ignoring the return status from the conversion function called below.
     * On overflow, the input string is simply truncated.
     */
    AcpiUtConvertHexString (String, &ConvertedInteger);
    return_VALUE (ConvertedInteger);
}

Referenced by AcpiExConvertToInteger().

AcpiUtStrtoul64()

ACPI_STATUS AcpiUtStrtoul64	(	char *	String,
		UINT64 *	ReturnValue
	)

Definition at line 121 of file utstrtoul64.c.

{
    ACPI_STATUS             Status = AE_OK;
    UINT8                   OriginalBitWidth;
    UINT32                  Base = 10;          /* Default is decimal */
 
 
    ACPI_FUNCTION_TRACE_STR (UtStrtoul64, String);
 
 
    *ReturnValue = 0;
 
    /* A NULL return string returns a value of zero */
 
    if (*String == 0)
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    if (!AcpiUtRemoveWhitespace (&String))
    {
        return_ACPI_STATUS (AE_OK);
    }
 
    /*
     * 1) Check for a hex constant. A "0x" prefix indicates base 16.
     */
    if (AcpiUtDetectHexPrefix (&String))
    {
        Base = 16;
    }
 
    /*
     * 2) Check for an octal constant, defined to be a leading zero
     * followed by sequence of octal digits (0-7)
     */
    else if (AcpiUtDetectOctalPrefix (&String))
    {
        Base = 8;
    }
 
    if (!AcpiUtRemoveLeadingZeros (&String))
    {
        return_ACPI_STATUS (AE_OK);     /* Return value 0 */
    }
 
    /*
     * Force a full 64-bit conversion. The caller (usually iASL) must
     * check for a 32-bit overflow later as necessary (If current mode
     * is 32-bit, meaning a 32-bit DSDT).
     */
    OriginalBitWidth = AcpiGbl_IntegerBitWidth;
    AcpiGbl_IntegerBitWidth = 64;
 
    /*
     * Perform the base 8, 10, or 16 conversion. A 64-bit numeric overflow
     * will return an exception (to allow iASL to flag the statement).
     */
    switch (Base)
    {
    case 8:
        Status = AcpiUtConvertOctalString (String, ReturnValue);
        break;
 
    case 10:
        Status = AcpiUtConvertDecimalString (String, ReturnValue);
        break;
 
    case 16:
    default:
        Status = AcpiUtConvertHexString (String, ReturnValue);
        break;
    }
 
    /* Only possible exception from above is a 64-bit overflow */
 
    AcpiGbl_IntegerBitWidth = OriginalBitWidth;
    return_ACPI_STATUS (Status);
}

Referenced by AcpiNsConvertToInteger().