utstrsuppt.c File Reference

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

Include dependency graph for utstrsuppt.c:

Go to the source code of this file.

Macros
#define	_COMPONENT   ACPI_UTILITIES

Functions
static ACPI_STATUS	AcpiUtInsertDigit (UINT64 *AccumulatedValue, UINT32 Base, int AsciiDigit)
static ACPI_STATUS	AcpiUtStrtoulMultiply64 (UINT64 Multiplicand, UINT32 Base, UINT64 *OutProduct)
static ACPI_STATUS	AcpiUtStrtoulAdd64 (UINT64 Addend1, UINT32 Digit, UINT64 *OutSum)
ACPI_STATUS	AcpiUtConvertOctalString (char *String, UINT64 *ReturnValuePtr)
ACPI_STATUS	AcpiUtConvertDecimalString (char *String, UINT64 *ReturnValuePtr)
ACPI_STATUS	AcpiUtConvertHexString (char *String, UINT64 *ReturnValuePtr)
char	AcpiUtRemoveLeadingZeros (char **String)
char	AcpiUtRemoveWhitespace (char **String)
BOOLEAN	AcpiUtDetectHexPrefix (char **String)
void	AcpiUtRemoveHexPrefix (char **String)
BOOLEAN	AcpiUtDetectOctalPrefix (char **String)

Macro Definition Documentation

_COMPONENT

#define _COMPONENT   ACPI_UTILITIES

Definition at line 47 of file utstrsuppt.c.

Function Documentation

AcpiUtConvertDecimalString()

ACPI_STATUS AcpiUtConvertDecimalString	(	char *	String,
		UINT64 *	ReturnValuePtr
	)

Definition at line 152 of file utstrsuppt.c.

{
    UINT64                  AccumulatedValue = 0;
    ACPI_STATUS             Status = AE_OK;
 
 
    /* Convert each ASCII byte in the input string */
 
    while (*String)
    {
        /*
         * Character must be ASCII 0-9, otherwise:
         * 1) Runtime: terminate with no error, per the ACPI spec
         * 2) Compiler: return an error
         */
        if (!isdigit ((int) *String))
        {
#ifdef ACPI_ASL_COMPILER
            Status = AE_BAD_DECIMAL_CONSTANT;
#endif
           break;
        }
 
        /* Convert and insert this decimal digit into the accumulator */
 
        Status = AcpiUtInsertDigit (&AccumulatedValue, 10, *String);
        if (ACPI_FAILURE (Status))
        {
            Status = AE_DECIMAL_OVERFLOW;
            break;
        }
 
        String++;
    }
 
    /* Always return the value that has been accumulated */
 
    *ReturnValuePtr = AccumulatedValue;
    return (Status);
}

Referenced by AcpiUtExplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtConvertHexString()

ACPI_STATUS AcpiUtConvertHexString	(	char *	String,
		UINT64 *	ReturnValuePtr
	)

Definition at line 214 of file utstrsuppt.c.

{
    UINT64                  AccumulatedValue = 0;
    ACPI_STATUS             Status = AE_OK;
 
 
    /* Convert each ASCII byte in the input string */
 
    while (*String)
    {
        /*
         * Character must be ASCII A-F, a-f, or 0-9, otherwise:
         * 1) Runtime: terminate with no error, per the ACPI spec
         * 2) Compiler: return an error
         */
        if (!isxdigit ((int) *String))
        {
#ifdef ACPI_ASL_COMPILER
            Status = AE_BAD_HEX_CONSTANT;
#endif
            break;
        }
 
        /* Convert and insert this hex digit into the accumulator */
 
        Status = AcpiUtInsertDigit (&AccumulatedValue, 16, *String);
        if (ACPI_FAILURE (Status))
        {
            Status = AE_HEX_OVERFLOW;
            break;
        }
 
        String++;
    }
 
    /* Always return the value that has been accumulated */
 
    *ReturnValuePtr = AccumulatedValue;
    return (Status);
}

Referenced by AcpiUtExplicitStrtoul64(), AcpiUtImplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtConvertOctalString()

ACPI_STATUS AcpiUtConvertOctalString	(	char *	String,
		UINT64 *	ReturnValuePtr
	)

Definition at line 90 of file utstrsuppt.c.

{
    UINT64                  AccumulatedValue = 0;
    ACPI_STATUS             Status = AE_OK;
 
 
    /* Convert each ASCII byte in the input string */
 
    while (*String)
    {
        /*
         * Character must be ASCII 0-7, otherwise:
         * 1) Runtime: terminate with no error, per the ACPI spec
         * 2) Compiler: return an error
         */
        if (!(ACPI_IS_OCTAL_DIGIT (*String)))
        {
#ifdef ACPI_ASL_COMPILER
            Status = AE_BAD_OCTAL_CONSTANT;
#endif
            break;
        }
 
        /* Convert and insert this octal digit into the accumulator */
 
        Status = AcpiUtInsertDigit (&AccumulatedValue, 8, *String);
        if (ACPI_FAILURE (Status))
        {
            Status = AE_OCTAL_OVERFLOW;
            break;
        }
 
        String++;
    }
 
    /* Always return the value that has been accumulated */
 
    *ReturnValuePtr = AccumulatedValue;
    return (Status);
}

Referenced by AcpiUtStrtoul64().

AcpiUtDetectHexPrefix()

BOOLEAN AcpiUtDetectHexPrefix

(

char **

String

)

Definition at line 329 of file utstrsuppt.c.

{
    char                    *InitialPosition = *String;
 
    AcpiUtRemoveHexPrefix (String);
    if (*String != InitialPosition)
    {
        return (TRUE); /* String is past leading 0x */
    }
 
    return (FALSE);     /* Not a hex string */
}

Referenced by AcpiUtExplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtDetectOctalPrefix()

BOOLEAN AcpiUtDetectOctalPrefix

(

char **

String

)

Definition at line 382 of file utstrsuppt.c.

{
 
    if (**String == ACPI_ASCII_ZERO)
    {
        *String += 1;       /* Go past the leading 0 */
        return (TRUE);
    }
 
    return (FALSE);     /* Not an octal string */
}

Referenced by AcpiUtStrtoul64().

AcpiUtInsertDigit()

static ACPI_STATUS AcpiUtInsertDigit ( UINT64 *  AccumulatedValue, UINT32  Base, int  AsciiDigit  )

static

Definition at line 424 of file utstrsuppt.c.

{
    ACPI_STATUS             Status;
    UINT64                  Product;
 
 
     /* Make room in the accumulated value for the incoming digit */
 
    Status = AcpiUtStrtoulMultiply64 (*AccumulatedValue, Base, &Product);
    if (ACPI_FAILURE (Status))
    {
        return (Status);
    }
 
    /* Add in the new digit, and store the sum to the accumulated value */
 
    Status = AcpiUtStrtoulAdd64 (Product, AcpiUtAsciiCharToHex (AsciiDigit),
        AccumulatedValue);
 
    return (Status);
}

Referenced by AcpiUtConvertDecimalString(), AcpiUtConvertHexString(), and AcpiUtConvertOctalString().

AcpiUtRemoveHexPrefix()

void AcpiUtRemoveHexPrefix

(

char **

String

)

Definition at line 357 of file utstrsuppt.c.

{
    if ((**String == ACPI_ASCII_ZERO) &&
        (tolower ((int) *(*String + 1)) == 'x'))
    {
        *String += 2;        /* Go past the leading 0x */
    }
}

Referenced by AcpiUtDetectHexPrefix(), and AcpiUtImplicitStrtoul64().

AcpiUtRemoveLeadingZeros()

char AcpiUtRemoveLeadingZeros

(

char **

String

)

Definition at line 274 of file utstrsuppt.c.

{
 
    while (**String == ACPI_ASCII_ZERO)
    {
        *String += 1;
    }
 
    return (**String);
}

Referenced by AcpiUtExplicitStrtoul64(), AcpiUtImplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtRemoveWhitespace()

char AcpiUtRemoveWhitespace

(

char **

String

)

Definition at line 303 of file utstrsuppt.c.

{
 
    while (isspace ((UINT8) **String))
    {
        *String += 1;
    }
 
    return (**String);
}

Referenced by AcpiUtExplicitStrtoul64(), AcpiUtImplicitStrtoul64(), and AcpiUtStrtoul64().

AcpiUtStrtoulAdd64()

static ACPI_STATUS AcpiUtStrtoulAdd64 ( UINT64  Addend1, UINT32  Digit, UINT64 *  OutSum  )

static

Definition at line 529 of file utstrsuppt.c.

{
    UINT64                  Sum;
 
 
    /* Check for 64-bit overflow before the actual addition */
 
    if ((Addend1 > 0) && (Digit > (ACPI_UINT64_MAX - Addend1)))
    {
        return (AE_NUMERIC_OVERFLOW);
    }
 
    Sum = Addend1 + Digit;
 
    /* Check for 32-bit overflow if necessary */
 
    if ((AcpiGbl_IntegerBitWidth == 32) && (Sum > ACPI_UINT32_MAX))
    {
        return (AE_NUMERIC_OVERFLOW);
    }
 
    *OutSum = Sum;
    return (AE_OK);
}

Referenced by AcpiUtInsertDigit().

AcpiUtStrtoulMultiply64()

static ACPI_STATUS AcpiUtStrtoulMultiply64 ( UINT64  Multiplicand, UINT32  Base, UINT64 *  OutProduct  )

static

Definition at line 467 of file utstrsuppt.c.

{
    UINT64                  Product;
    UINT64                  Quotient;
 
 
    /* Exit if either operand is zero */
 
    *OutProduct = 0;
    if (!Multiplicand || !Base)
    {
        return (AE_OK);
    }
 
    /*
     * Check for 64-bit overflow before the actual multiplication.
     *
     * Notes: 64-bit division is often not supported on 32-bit platforms
     * (it requires a library function), Therefore ACPICA has a local
     * 64-bit divide function. Also, Multiplier is currently only used
     * as the radix (8/10/16), to the 64/32 divide will always work.
     */
    AcpiUtShortDivide (ACPI_UINT64_MAX, Base, &Quotient, NULL);
    if (Multiplicand > Quotient)
    {
        return (AE_NUMERIC_OVERFLOW);
    }
 
    Product = Multiplicand * Base;
 
    /* Check for 32-bit overflow if necessary */
 
    if ((AcpiGbl_IntegerBitWidth == 32) && (Product > ACPI_UINT32_MAX))
    {
        return (AE_NUMERIC_OVERFLOW);
    }
 
    *OutProduct = Product;
    return (AE_OK);
}

Referenced by AcpiUtInsertDigit().