xref: /freebsd/sys/contrib/dev/acpica/compiler/aslutils.c (revision 9a179dd8bec7b25fb577262c606fddfb5da50ffc)
153289f6aSNate Lawson 
253289f6aSNate Lawson /******************************************************************************
353289f6aSNate Lawson  *
453289f6aSNate Lawson  * Module Name: aslutils -- compiler utilities
553289f6aSNate Lawson  *
653289f6aSNate Lawson  *****************************************************************************/
753289f6aSNate Lawson 
853289f6aSNate Lawson /******************************************************************************
953289f6aSNate Lawson  *
1053289f6aSNate Lawson  * 1. Copyright Notice
1153289f6aSNate Lawson  *
129a179dd8SJung-uk Kim  * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
1353289f6aSNate Lawson  * All rights reserved.
1453289f6aSNate Lawson  *
1553289f6aSNate Lawson  * 2. License
1653289f6aSNate Lawson  *
1753289f6aSNate Lawson  * 2.1. This is your license from Intel Corp. under its intellectual property
1853289f6aSNate Lawson  * rights.  You may have additional license terms from the party that provided
1953289f6aSNate Lawson  * you this software, covering your right to use that party's intellectual
2053289f6aSNate Lawson  * property rights.
2153289f6aSNate Lawson  *
2253289f6aSNate Lawson  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
2353289f6aSNate Lawson  * copy of the source code appearing in this file ("Covered Code") an
2453289f6aSNate Lawson  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
2553289f6aSNate Lawson  * base code distributed originally by Intel ("Original Intel Code") to copy,
2653289f6aSNate Lawson  * make derivatives, distribute, use and display any portion of the Covered
2753289f6aSNate Lawson  * Code in any form, with the right to sublicense such rights; and
2853289f6aSNate Lawson  *
2953289f6aSNate Lawson  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
3053289f6aSNate Lawson  * license (with the right to sublicense), under only those claims of Intel
3153289f6aSNate Lawson  * patents that are infringed by the Original Intel Code, to make, use, sell,
3253289f6aSNate Lawson  * offer to sell, and import the Covered Code and derivative works thereof
3353289f6aSNate Lawson  * solely to the minimum extent necessary to exercise the above copyright
3453289f6aSNate Lawson  * license, and in no event shall the patent license extend to any additions
3553289f6aSNate Lawson  * to or modifications of the Original Intel Code.  No other license or right
3653289f6aSNate Lawson  * is granted directly or by implication, estoppel or otherwise;
3753289f6aSNate Lawson  *
3853289f6aSNate Lawson  * The above copyright and patent license is granted only if the following
3953289f6aSNate Lawson  * conditions are met:
4053289f6aSNate Lawson  *
4153289f6aSNate Lawson  * 3. Conditions
4253289f6aSNate Lawson  *
4353289f6aSNate Lawson  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
4453289f6aSNate Lawson  * Redistribution of source code of any substantial portion of the Covered
4553289f6aSNate Lawson  * Code or modification with rights to further distribute source must include
4653289f6aSNate Lawson  * the above Copyright Notice, the above License, this list of Conditions,
4753289f6aSNate Lawson  * and the following Disclaimer and Export Compliance provision.  In addition,
4853289f6aSNate Lawson  * Licensee must cause all Covered Code to which Licensee contributes to
4953289f6aSNate Lawson  * contain a file documenting the changes Licensee made to create that Covered
5053289f6aSNate Lawson  * Code and the date of any change.  Licensee must include in that file the
5153289f6aSNate Lawson  * documentation of any changes made by any predecessor Licensee.  Licensee
5253289f6aSNate Lawson  * must include a prominent statement that the modification is derived,
5353289f6aSNate Lawson  * directly or indirectly, from Original Intel Code.
5453289f6aSNate Lawson  *
5553289f6aSNate Lawson  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
5653289f6aSNate Lawson  * Redistribution of source code of any substantial portion of the Covered
5753289f6aSNate Lawson  * Code or modification without rights to further distribute source must
5853289f6aSNate Lawson  * include the following Disclaimer and Export Compliance provision in the
5953289f6aSNate Lawson  * documentation and/or other materials provided with distribution.  In
6053289f6aSNate Lawson  * addition, Licensee may not authorize further sublicense of source of any
6153289f6aSNate Lawson  * portion of the Covered Code, and must include terms to the effect that the
6253289f6aSNate Lawson  * license from Licensee to its licensee is limited to the intellectual
6353289f6aSNate Lawson  * property embodied in the software Licensee provides to its licensee, and
6453289f6aSNate Lawson  * not to intellectual property embodied in modifications its licensee may
6553289f6aSNate Lawson  * make.
6653289f6aSNate Lawson  *
6753289f6aSNate Lawson  * 3.3. Redistribution of Executable. Redistribution in executable form of any
6853289f6aSNate Lawson  * substantial portion of the Covered Code or modification must reproduce the
6953289f6aSNate Lawson  * above Copyright Notice, and the following Disclaimer and Export Compliance
7053289f6aSNate Lawson  * provision in the documentation and/or other materials provided with the
7153289f6aSNate Lawson  * distribution.
7253289f6aSNate Lawson  *
7353289f6aSNate Lawson  * 3.4. Intel retains all right, title, and interest in and to the Original
7453289f6aSNate Lawson  * Intel Code.
7553289f6aSNate Lawson  *
7653289f6aSNate Lawson  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
7753289f6aSNate Lawson  * Intel shall be used in advertising or otherwise to promote the sale, use or
7853289f6aSNate Lawson  * other dealings in products derived from or relating to the Covered Code
7953289f6aSNate Lawson  * without prior written authorization from Intel.
8053289f6aSNate Lawson  *
8153289f6aSNate Lawson  * 4. Disclaimer and Export Compliance
8253289f6aSNate Lawson  *
8353289f6aSNate Lawson  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
8453289f6aSNate Lawson  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
8553289f6aSNate Lawson  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
8653289f6aSNate Lawson  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
8753289f6aSNate Lawson  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
8853289f6aSNate Lawson  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
8953289f6aSNate Lawson  * PARTICULAR PURPOSE.
9053289f6aSNate Lawson  *
9153289f6aSNate Lawson  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
9253289f6aSNate Lawson  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
9353289f6aSNate Lawson  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
9453289f6aSNate Lawson  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
9553289f6aSNate Lawson  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
9653289f6aSNate Lawson  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
9753289f6aSNate Lawson  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
9853289f6aSNate Lawson  * LIMITED REMEDY.
9953289f6aSNate Lawson  *
10053289f6aSNate Lawson  * 4.3. Licensee shall not export, either directly or indirectly, any of this
10153289f6aSNate Lawson  * software or system incorporating such software without first obtaining any
10253289f6aSNate Lawson  * required license or other approval from the U. S. Department of Commerce or
10353289f6aSNate Lawson  * any other agency or department of the United States Government.  In the
10453289f6aSNate Lawson  * event Licensee exports any such software from the United States or
10553289f6aSNate Lawson  * re-exports any such software from a foreign destination, Licensee shall
10653289f6aSNate Lawson  * ensure that the distribution and export/re-export of the software is in
10753289f6aSNate Lawson  * compliance with all laws, regulations, orders, or other restrictions of the
10853289f6aSNate Lawson  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
10953289f6aSNate Lawson  * any of its subsidiaries will export/re-export any technical data, process,
11053289f6aSNate Lawson  * software, or service, directly or indirectly, to any country for which the
11153289f6aSNate Lawson  * United States government or any agency thereof requires an export license,
11253289f6aSNate Lawson  * other governmental approval, or letter of assurance, without first obtaining
11353289f6aSNate Lawson  * such license, approval or letter.
11453289f6aSNate Lawson  *
11553289f6aSNate Lawson  *****************************************************************************/
11653289f6aSNate Lawson 
11753289f6aSNate Lawson 
118ab6f3bf9SJung-uk Kim #include <contrib/dev/acpica/compiler/aslcompiler.h>
11953289f6aSNate Lawson #include "aslcompiler.y.h"
120ab6f3bf9SJung-uk Kim #include <contrib/dev/acpica/include/acnamesp.h>
121ab6f3bf9SJung-uk Kim #include <contrib/dev/acpica/include/amlcode.h>
12253289f6aSNate Lawson 
12353289f6aSNate Lawson #define _COMPONENT          ACPI_COMPILER
12453289f6aSNate Lawson         ACPI_MODULE_NAME    ("aslutils")
12553289f6aSNate Lawson 
12653289f6aSNate Lawson #ifdef _USE_BERKELEY_YACC
12753289f6aSNate Lawson extern const char * const       AslCompilername[];
1280161891aSNate Lawson static const char * const       *yytname = &AslCompilername[254];
12953289f6aSNate Lawson #else
13053289f6aSNate Lawson extern const char * const       yytname[];
13153289f6aSNate Lawson #endif
13253289f6aSNate Lawson 
133a9f12690SJung-uk Kim char                    HexLookup[] =
134a9f12690SJung-uk Kim {
135a9f12690SJung-uk Kim     '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
136a9f12690SJung-uk Kim };
137a9f12690SJung-uk Kim 
138a9f12690SJung-uk Kim 
139fba7fc7eSJung-uk Kim /* Local prototypes */
14053289f6aSNate Lawson 
141fba7fc7eSJung-uk Kim static ACPI_STATUS
142fba7fc7eSJung-uk Kim UtStrtoul64 (
143fba7fc7eSJung-uk Kim     char                    *String,
144fba7fc7eSJung-uk Kim     UINT32                  Base,
1459a179dd8SJung-uk Kim     UINT64                  *RetInteger);
146fba7fc7eSJung-uk Kim 
147fba7fc7eSJung-uk Kim static void
148fba7fc7eSJung-uk Kim UtPadNameWithUnderscores (
149fba7fc7eSJung-uk Kim     char                    *NameSeg,
150fba7fc7eSJung-uk Kim     char                    *PaddedNameSeg);
151fba7fc7eSJung-uk Kim 
152fba7fc7eSJung-uk Kim static void
153fba7fc7eSJung-uk Kim UtAttachNameseg (
154fba7fc7eSJung-uk Kim     ACPI_PARSE_OBJECT       *Op,
155fba7fc7eSJung-uk Kim     char                    *Name);
15653289f6aSNate Lawson 
15753289f6aSNate Lawson 
15853289f6aSNate Lawson /*******************************************************************************
15953289f6aSNate Lawson  *
16053289f6aSNate Lawson  * FUNCTION:    AcpiPsDisplayConstantOpcodes
16153289f6aSNate Lawson  *
16253289f6aSNate Lawson  * PARAMETERS:  None
16353289f6aSNate Lawson  *
16453289f6aSNate Lawson  * RETURN:      None
16553289f6aSNate Lawson  *
16653289f6aSNate Lawson  * DESCRIPTION: Print AML opcodes that can be used in constant expressions.
16753289f6aSNate Lawson  *
16853289f6aSNate Lawson  ******************************************************************************/
16953289f6aSNate Lawson 
17053289f6aSNate Lawson void
17153289f6aSNate Lawson UtDisplayConstantOpcodes (
17253289f6aSNate Lawson     void)
17353289f6aSNate Lawson {
17453289f6aSNate Lawson     UINT32                  i;
17553289f6aSNate Lawson 
176fba7fc7eSJung-uk Kim 
17753289f6aSNate Lawson     printf ("Constant expression opcode information\n\n");
17853289f6aSNate Lawson 
17953289f6aSNate Lawson     for (i = 0; i < sizeof (AcpiGbl_AmlOpInfo) / sizeof (ACPI_OPCODE_INFO); i++)
18053289f6aSNate Lawson     {
18153289f6aSNate Lawson         if (AcpiGbl_AmlOpInfo[i].Flags & AML_CONSTANT)
18253289f6aSNate Lawson         {
18353289f6aSNate Lawson             printf ("%s\n", AcpiGbl_AmlOpInfo[i].Name);
18453289f6aSNate Lawson         }
18553289f6aSNate Lawson     }
18653289f6aSNate Lawson }
18753289f6aSNate Lawson 
18853289f6aSNate Lawson 
18953289f6aSNate Lawson /*******************************************************************************
19053289f6aSNate Lawson  *
19153289f6aSNate Lawson  * FUNCTION:    UtLocalCalloc
19253289f6aSNate Lawson  *
19353289f6aSNate Lawson  * PARAMETERS:  Size        - Bytes to be allocated
19453289f6aSNate Lawson  *
19553289f6aSNate Lawson  * RETURN:      Pointer to the allocated memory.  Guaranteed to be valid.
19653289f6aSNate Lawson  *
19753289f6aSNate Lawson  * DESCRIPTION: Allocate zero-initialized memory.  Aborts the compile on an
19853289f6aSNate Lawson  *              allocation failure, on the assumption that nothing more can be
19953289f6aSNate Lawson  *              accomplished.
20053289f6aSNate Lawson  *
20153289f6aSNate Lawson  ******************************************************************************/
20253289f6aSNate Lawson 
20353289f6aSNate Lawson void *
20453289f6aSNate Lawson UtLocalCalloc (
20553289f6aSNate Lawson     UINT32                  Size)
20653289f6aSNate Lawson {
20753289f6aSNate Lawson     void                    *Allocated;
20853289f6aSNate Lawson 
20953289f6aSNate Lawson 
2101a39cfb0SJung-uk Kim     Allocated = ACPI_ALLOCATE_ZEROED (Size);
21153289f6aSNate Lawson     if (!Allocated)
21253289f6aSNate Lawson     {
21353289f6aSNate Lawson         AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
21453289f6aSNate Lawson             Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
21553289f6aSNate Lawson             Gbl_InputByteCount, Gbl_CurrentColumn,
21653289f6aSNate Lawson             Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
21753289f6aSNate Lawson         exit (1);
21853289f6aSNate Lawson     }
21953289f6aSNate Lawson 
22053289f6aSNate Lawson     TotalAllocations++;
22153289f6aSNate Lawson     TotalAllocated += Size;
2221a39cfb0SJung-uk Kim     return (Allocated);
22353289f6aSNate Lawson }
22453289f6aSNate Lawson 
22553289f6aSNate Lawson 
22653289f6aSNate Lawson /*******************************************************************************
22753289f6aSNate Lawson  *
22853289f6aSNate Lawson  * FUNCTION:    UtBeginEvent
22953289f6aSNate Lawson  *
230fba7fc7eSJung-uk Kim  * PARAMETERS:  Name        - Ascii name of this event
23153289f6aSNate Lawson  *
232fba7fc7eSJung-uk Kim  * RETURN:      Event       - Event number (integer index)
23353289f6aSNate Lawson  *
23453289f6aSNate Lawson  * DESCRIPTION: Saves the current time with this event
23553289f6aSNate Lawson  *
23653289f6aSNate Lawson  ******************************************************************************/
23753289f6aSNate Lawson 
238fba7fc7eSJung-uk Kim UINT8
23953289f6aSNate Lawson UtBeginEvent (
24053289f6aSNate Lawson     char                    *Name)
24153289f6aSNate Lawson {
24253289f6aSNate Lawson 
243fba7fc7eSJung-uk Kim     if (AslGbl_NextEvent >= ASL_NUM_EVENTS)
244fba7fc7eSJung-uk Kim     {
245fba7fc7eSJung-uk Kim         AcpiOsPrintf ("Ran out of compiler event structs!\n");
246fba7fc7eSJung-uk Kim         return (AslGbl_NextEvent);
247fba7fc7eSJung-uk Kim     }
248fba7fc7eSJung-uk Kim 
249fba7fc7eSJung-uk Kim     /* Init event with current (start) time */
250fba7fc7eSJung-uk Kim 
251fba7fc7eSJung-uk Kim     AslGbl_Events[AslGbl_NextEvent].StartTime = AcpiOsGetTimer ();
252fba7fc7eSJung-uk Kim     AslGbl_Events[AslGbl_NextEvent].EventName = Name;
253fba7fc7eSJung-uk Kim     AslGbl_Events[AslGbl_NextEvent].Valid = TRUE;
254fba7fc7eSJung-uk Kim 
255fba7fc7eSJung-uk Kim     return (AslGbl_NextEvent++);
25653289f6aSNate Lawson }
25753289f6aSNate Lawson 
25853289f6aSNate Lawson 
25953289f6aSNate Lawson /*******************************************************************************
26053289f6aSNate Lawson  *
26153289f6aSNate Lawson  * FUNCTION:    UtEndEvent
26253289f6aSNate Lawson  *
26353289f6aSNate Lawson  * PARAMETERS:  Event       - Event number (integer index)
26453289f6aSNate Lawson  *
26553289f6aSNate Lawson  * RETURN:      None
26653289f6aSNate Lawson  *
26753289f6aSNate Lawson  * DESCRIPTION: Saves the current time (end time) with this event
26853289f6aSNate Lawson  *
26953289f6aSNate Lawson  ******************************************************************************/
27053289f6aSNate Lawson 
27153289f6aSNate Lawson void
27253289f6aSNate Lawson UtEndEvent (
273fba7fc7eSJung-uk Kim     UINT8                  Event)
27453289f6aSNate Lawson {
27553289f6aSNate Lawson 
276fba7fc7eSJung-uk Kim     if (Event >= ASL_NUM_EVENTS)
277fba7fc7eSJung-uk Kim     {
278fba7fc7eSJung-uk Kim         return;
279fba7fc7eSJung-uk Kim     }
280fba7fc7eSJung-uk Kim 
281fba7fc7eSJung-uk Kim     /* Insert end time for event */
282fba7fc7eSJung-uk Kim 
283fba7fc7eSJung-uk Kim     AslGbl_Events[Event].EndTime = AcpiOsGetTimer ();
28453289f6aSNate Lawson }
28553289f6aSNate Lawson 
28653289f6aSNate Lawson 
28753289f6aSNate Lawson /*******************************************************************************
28853289f6aSNate Lawson  *
28953289f6aSNate Lawson  * FUNCTION:    UtHexCharToValue
29053289f6aSNate Lawson  *
291fba7fc7eSJung-uk Kim  * PARAMETERS:  HexChar         - Hex character in Ascii
29253289f6aSNate Lawson  *
29353289f6aSNate Lawson  * RETURN:      The binary value of the hex character
29453289f6aSNate Lawson  *
29553289f6aSNate Lawson  * DESCRIPTION: Perform ascii-to-hex translation
29653289f6aSNate Lawson  *
29753289f6aSNate Lawson  ******************************************************************************/
29853289f6aSNate Lawson 
29953289f6aSNate Lawson UINT8
30053289f6aSNate Lawson UtHexCharToValue (
301fba7fc7eSJung-uk Kim     int                     HexChar)
30253289f6aSNate Lawson {
30353289f6aSNate Lawson 
304fba7fc7eSJung-uk Kim     if (HexChar <= 0x39)
30553289f6aSNate Lawson     {
306fba7fc7eSJung-uk Kim         return ((UINT8) (HexChar - 0x30));
30753289f6aSNate Lawson     }
30853289f6aSNate Lawson 
309fba7fc7eSJung-uk Kim     if (HexChar <= 0x46)
31053289f6aSNate Lawson     {
311fba7fc7eSJung-uk Kim         return ((UINT8) (HexChar - 0x37));
31253289f6aSNate Lawson     }
31353289f6aSNate Lawson 
314fba7fc7eSJung-uk Kim     return ((UINT8) (HexChar - 0x57));
31553289f6aSNate Lawson }
31653289f6aSNate Lawson 
31753289f6aSNate Lawson 
31853289f6aSNate Lawson /*******************************************************************************
31953289f6aSNate Lawson  *
32053289f6aSNate Lawson  * FUNCTION:    UtConvertByteToHex
32153289f6aSNate Lawson  *
32253289f6aSNate Lawson  * PARAMETERS:  RawByte         - Binary data
323fba7fc7eSJung-uk Kim  *              Buffer          - Pointer to where the hex bytes will be stored
32453289f6aSNate Lawson  *
32553289f6aSNate Lawson  * RETURN:      Ascii hex byte is stored in Buffer.
32653289f6aSNate Lawson  *
32753289f6aSNate Lawson  * DESCRIPTION: Perform hex-to-ascii translation.  The return data is prefixed
32853289f6aSNate Lawson  *              with "0x"
32953289f6aSNate Lawson  *
33053289f6aSNate Lawson  ******************************************************************************/
33153289f6aSNate Lawson 
33253289f6aSNate Lawson void
33353289f6aSNate Lawson UtConvertByteToHex (
33453289f6aSNate Lawson     UINT8                   RawByte,
33553289f6aSNate Lawson     UINT8                   *Buffer)
33653289f6aSNate Lawson {
33753289f6aSNate Lawson 
33853289f6aSNate Lawson     Buffer[0] = '0';
33953289f6aSNate Lawson     Buffer[1] = 'x';
34053289f6aSNate Lawson 
341a9f12690SJung-uk Kim     Buffer[2] = (UINT8) HexLookup[(RawByte >> 4) & 0xF];
342a9f12690SJung-uk Kim     Buffer[3] = (UINT8) HexLookup[RawByte & 0xF];
34353289f6aSNate Lawson }
34453289f6aSNate Lawson 
34553289f6aSNate Lawson 
34653289f6aSNate Lawson /*******************************************************************************
34753289f6aSNate Lawson  *
34853289f6aSNate Lawson  * FUNCTION:    UtConvertByteToAsmHex
34953289f6aSNate Lawson  *
35053289f6aSNate Lawson  * PARAMETERS:  RawByte         - Binary data
351fba7fc7eSJung-uk Kim  *              Buffer          - Pointer to where the hex bytes will be stored
35253289f6aSNate Lawson  *
35353289f6aSNate Lawson  * RETURN:      Ascii hex byte is stored in Buffer.
35453289f6aSNate Lawson  *
35553289f6aSNate Lawson  * DESCRIPTION: Perform hex-to-ascii translation.  The return data is prefixed
35653289f6aSNate Lawson  *              with "0x"
35753289f6aSNate Lawson  *
35853289f6aSNate Lawson  ******************************************************************************/
35953289f6aSNate Lawson 
36053289f6aSNate Lawson void
36153289f6aSNate Lawson UtConvertByteToAsmHex (
36253289f6aSNate Lawson     UINT8                   RawByte,
36353289f6aSNate Lawson     UINT8                   *Buffer)
36453289f6aSNate Lawson {
36553289f6aSNate Lawson 
36653289f6aSNate Lawson     Buffer[0] = '0';
367a9f12690SJung-uk Kim     Buffer[1] = (UINT8) HexLookup[(RawByte >> 4) & 0xF];
368a9f12690SJung-uk Kim     Buffer[2] = (UINT8) HexLookup[RawByte & 0xF];
36953289f6aSNate Lawson     Buffer[3] = 'h';
37053289f6aSNate Lawson }
37153289f6aSNate Lawson 
37253289f6aSNate Lawson 
37353289f6aSNate Lawson /*******************************************************************************
37453289f6aSNate Lawson  *
37553289f6aSNate Lawson  * FUNCTION:    DbgPrint
37653289f6aSNate Lawson  *
377fba7fc7eSJung-uk Kim  * PARAMETERS:  Type            - Type of output
378fba7fc7eSJung-uk Kim  *              Fmt             - Printf format string
37953289f6aSNate Lawson  *              ...             - variable printf list
38053289f6aSNate Lawson  *
38153289f6aSNate Lawson  * RETURN:      None
38253289f6aSNate Lawson  *
38353289f6aSNate Lawson  * DESCRIPTION: Conditional print statement.  Prints to stderr only if the
38453289f6aSNate Lawson  *              debug flag is set.
38553289f6aSNate Lawson  *
38653289f6aSNate Lawson  ******************************************************************************/
38753289f6aSNate Lawson 
38853289f6aSNate Lawson void
38953289f6aSNate Lawson DbgPrint (
39053289f6aSNate Lawson     UINT32                  Type,
39153289f6aSNate Lawson     char                    *Fmt,
39253289f6aSNate Lawson     ...)
39353289f6aSNate Lawson {
39453289f6aSNate Lawson     va_list                 Args;
39553289f6aSNate Lawson 
39653289f6aSNate Lawson 
39753289f6aSNate Lawson     va_start (Args, Fmt);
39853289f6aSNate Lawson 
39953289f6aSNate Lawson     if (!Gbl_DebugFlag)
40053289f6aSNate Lawson     {
40153289f6aSNate Lawson         return;
40253289f6aSNate Lawson     }
40353289f6aSNate Lawson 
40453289f6aSNate Lawson     if ((Type == ASL_PARSE_OUTPUT) &&
40553289f6aSNate Lawson         (!(AslCompilerdebug)))
40653289f6aSNate Lawson     {
40753289f6aSNate Lawson         return;
40853289f6aSNate Lawson     }
40953289f6aSNate Lawson 
41053289f6aSNate Lawson     (void) vfprintf (stderr, Fmt, Args);
41153289f6aSNate Lawson     va_end (Args);
41253289f6aSNate Lawson     return;
41353289f6aSNate Lawson }
41453289f6aSNate Lawson 
41553289f6aSNate Lawson 
41653289f6aSNate Lawson /*******************************************************************************
41753289f6aSNate Lawson  *
41853289f6aSNate Lawson  * FUNCTION:    UtPrintFormattedName
41953289f6aSNate Lawson  *
42053289f6aSNate Lawson  * PARAMETERS:  ParseOpcode         - Parser keyword ID
42153289f6aSNate Lawson  *              Level               - Indentation level
42253289f6aSNate Lawson  *
42353289f6aSNate Lawson  * RETURN:      None
42453289f6aSNate Lawson  *
42553289f6aSNate Lawson  * DESCRIPTION: Print the ascii name of the parse opcode.
42653289f6aSNate Lawson  *
42753289f6aSNate Lawson  ******************************************************************************/
42853289f6aSNate Lawson 
42953289f6aSNate Lawson #define TEXT_OFFSET 10
43053289f6aSNate Lawson 
43153289f6aSNate Lawson void
43253289f6aSNate Lawson UtPrintFormattedName (
43353289f6aSNate Lawson     UINT16                  ParseOpcode,
43453289f6aSNate Lawson     UINT32                  Level)
43553289f6aSNate Lawson {
43653289f6aSNate Lawson 
4371a39cfb0SJung-uk Kim     if (Level)
4381a39cfb0SJung-uk Kim     {
43953289f6aSNate Lawson         DbgPrint (ASL_TREE_OUTPUT,
4401a39cfb0SJung-uk Kim             "%*s", (3 * Level), " ");
4411a39cfb0SJung-uk Kim     }
4421a39cfb0SJung-uk Kim     DbgPrint (ASL_TREE_OUTPUT,
4431a39cfb0SJung-uk Kim         " %-20.20s", UtGetOpName (ParseOpcode));
44453289f6aSNate Lawson 
44553289f6aSNate Lawson     if (Level < TEXT_OFFSET)
44653289f6aSNate Lawson     {
44753289f6aSNate Lawson         DbgPrint (ASL_TREE_OUTPUT,
44853289f6aSNate Lawson             "%*s", (TEXT_OFFSET - Level) * 3, " ");
44953289f6aSNate Lawson     }
45053289f6aSNate Lawson }
45153289f6aSNate Lawson 
45253289f6aSNate Lawson 
45353289f6aSNate Lawson /*******************************************************************************
45453289f6aSNate Lawson  *
45553289f6aSNate Lawson  * FUNCTION:    UtSetParseOpName
45653289f6aSNate Lawson  *
45753289f6aSNate Lawson  * PARAMETERS:  Op
45853289f6aSNate Lawson  *
45953289f6aSNate Lawson  * RETURN:      None
46053289f6aSNate Lawson  *
46153289f6aSNate Lawson  * DESCRIPTION: Insert the ascii name of the parse opcode
46253289f6aSNate Lawson  *
46353289f6aSNate Lawson  ******************************************************************************/
46453289f6aSNate Lawson 
46553289f6aSNate Lawson void
46653289f6aSNate Lawson UtSetParseOpName (
46753289f6aSNate Lawson     ACPI_PARSE_OBJECT       *Op)
46853289f6aSNate Lawson {
469fba7fc7eSJung-uk Kim 
4701a39cfb0SJung-uk Kim     strncpy (Op->Asl.ParseOpName, UtGetOpName (Op->Asl.ParseOpcode),
4711a39cfb0SJung-uk Kim         ACPI_MAX_PARSEOP_NAME);
47253289f6aSNate Lawson }
47353289f6aSNate Lawson 
47453289f6aSNate Lawson 
47553289f6aSNate Lawson /*******************************************************************************
47653289f6aSNate Lawson  *
47753289f6aSNate Lawson  * FUNCTION:    UtGetOpName
47853289f6aSNate Lawson  *
47953289f6aSNate Lawson  * PARAMETERS:  ParseOpcode         - Parser keyword ID
48053289f6aSNate Lawson  *
48153289f6aSNate Lawson  * RETURN:      Pointer to the opcode name
48253289f6aSNate Lawson  *
48353289f6aSNate Lawson  * DESCRIPTION: Get the ascii name of the parse opcode
48453289f6aSNate Lawson  *
48553289f6aSNate Lawson  ******************************************************************************/
48653289f6aSNate Lawson 
48753289f6aSNate Lawson char *
48853289f6aSNate Lawson UtGetOpName (
48953289f6aSNate Lawson     UINT32                  ParseOpcode)
49053289f6aSNate Lawson {
49153289f6aSNate Lawson 
49253289f6aSNate Lawson     /*
49353289f6aSNate Lawson      * First entries (ASL_YYTNAME_START) in yytname are special reserved names.
49453289f6aSNate Lawson      * Ignore first 8 characters of the name
49553289f6aSNate Lawson      */
4961a39cfb0SJung-uk Kim     return ((char *) yytname
4971a39cfb0SJung-uk Kim         [(ParseOpcode - ASL_FIRST_PARSE_OPCODE) + ASL_YYTNAME_START] + 8);
49853289f6aSNate Lawson }
49953289f6aSNate Lawson 
50053289f6aSNate Lawson 
50153289f6aSNate Lawson /*******************************************************************************
50253289f6aSNate Lawson  *
50353289f6aSNate Lawson  * FUNCTION:    UtDisplaySummary
50453289f6aSNate Lawson  *
505fba7fc7eSJung-uk Kim  * PARAMETERS:  FileID          - ID of outpout file
50653289f6aSNate Lawson  *
50753289f6aSNate Lawson  * RETURN:      None
50853289f6aSNate Lawson  *
50953289f6aSNate Lawson  * DESCRIPTION: Display compilation statistics
51053289f6aSNate Lawson  *
51153289f6aSNate Lawson  ******************************************************************************/
51253289f6aSNate Lawson 
51353289f6aSNate Lawson void
51453289f6aSNate Lawson UtDisplaySummary (
51553289f6aSNate Lawson     UINT32                  FileId)
51653289f6aSNate Lawson {
51753289f6aSNate Lawson 
51853289f6aSNate Lawson     if (FileId != ASL_FILE_STDOUT)
51953289f6aSNate Lawson     {
52053289f6aSNate Lawson         /* Compiler name and version number */
52153289f6aSNate Lawson 
5227d845ddeSColin Percival         FlPrintFile (FileId, "%s version %X\n",
5237d845ddeSColin Percival             CompilerId, (UINT32) ACPI_CA_VERSION);
52453289f6aSNate Lawson     }
52553289f6aSNate Lawson 
52653289f6aSNate Lawson     /* Input/Output summary */
52753289f6aSNate Lawson 
52853289f6aSNate Lawson     FlPrintFile (FileId,
52953289f6aSNate Lawson         "ASL Input:  %s - %d lines, %d bytes, %d keywords\n",
53053289f6aSNate Lawson         Gbl_Files[ASL_FILE_INPUT].Filename, Gbl_CurrentLineNumber,
53153289f6aSNate Lawson         Gbl_InputByteCount, TotalKeywords);
53253289f6aSNate Lawson 
53353289f6aSNate Lawson     /* AML summary */
53453289f6aSNate Lawson 
53553289f6aSNate Lawson     if ((Gbl_ExceptionCount[ASL_ERROR] == 0) || (Gbl_IgnoreErrors))
53653289f6aSNate Lawson     {
53753289f6aSNate Lawson         FlPrintFile (FileId,
538a9f12690SJung-uk Kim             "AML Output: %s - %d bytes, %d named objects, %d executable opcodes\n\n",
53953289f6aSNate Lawson             Gbl_Files[ASL_FILE_AML_OUTPUT].Filename, Gbl_TableLength,
54053289f6aSNate Lawson             TotalNamedObjects, TotalExecutableOpcodes);
54153289f6aSNate Lawson     }
54253289f6aSNate Lawson 
54353289f6aSNate Lawson     /* Error summary */
54453289f6aSNate Lawson 
54553289f6aSNate Lawson     FlPrintFile (FileId,
54653289f6aSNate Lawson         "Compilation complete. %d Errors, %d Warnings, %d Remarks, %d Optimizations\n",
54753289f6aSNate Lawson         Gbl_ExceptionCount[ASL_ERROR],
5481a39cfb0SJung-uk Kim         Gbl_ExceptionCount[ASL_WARNING] +
5491a39cfb0SJung-uk Kim             Gbl_ExceptionCount[ASL_WARNING2] +
5501a39cfb0SJung-uk Kim             Gbl_ExceptionCount[ASL_WARNING3],
55153289f6aSNate Lawson         Gbl_ExceptionCount[ASL_REMARK],
55253289f6aSNate Lawson         Gbl_ExceptionCount[ASL_OPTIMIZATION]);
55353289f6aSNate Lawson }
55453289f6aSNate Lawson 
55553289f6aSNate Lawson 
55653289f6aSNate Lawson /*******************************************************************************
55753289f6aSNate Lawson  *
55853289f6aSNate Lawson  * FUNCTION:    UtDisplaySummary
55953289f6aSNate Lawson  *
56053289f6aSNate Lawson  * PARAMETERS:  Op              - Integer parse node
56153289f6aSNate Lawson  *              LowValue        - Smallest allowed value
56253289f6aSNate Lawson  *              HighValue       - Largest allowed value
56353289f6aSNate Lawson  *
56453289f6aSNate Lawson  * RETURN:      Op if OK, otherwise NULL
56553289f6aSNate Lawson  *
56653289f6aSNate Lawson  * DESCRIPTION: Check integer for an allowable range
56753289f6aSNate Lawson  *
56853289f6aSNate Lawson  ******************************************************************************/
56953289f6aSNate Lawson 
57053289f6aSNate Lawson ACPI_PARSE_OBJECT *
57153289f6aSNate Lawson UtCheckIntegerRange (
57253289f6aSNate Lawson     ACPI_PARSE_OBJECT       *Op,
57353289f6aSNate Lawson     UINT32                  LowValue,
57453289f6aSNate Lawson     UINT32                  HighValue)
57553289f6aSNate Lawson {
57653289f6aSNate Lawson     char                    *ParseError = NULL;
57753289f6aSNate Lawson     char                    Buffer[64];
57853289f6aSNate Lawson 
57953289f6aSNate Lawson 
58053289f6aSNate Lawson     if (!Op)
58153289f6aSNate Lawson     {
58253289f6aSNate Lawson         return NULL;
58353289f6aSNate Lawson     }
58453289f6aSNate Lawson 
58553289f6aSNate Lawson     if (Op->Asl.Value.Integer < LowValue)
58653289f6aSNate Lawson     {
58753289f6aSNate Lawson         ParseError = "Value below valid range";
58853289f6aSNate Lawson         Op->Asl.Value.Integer = LowValue;
58953289f6aSNate Lawson     }
59053289f6aSNate Lawson 
59153289f6aSNate Lawson     if (Op->Asl.Value.Integer > HighValue)
59253289f6aSNate Lawson     {
59353289f6aSNate Lawson         ParseError = "Value above valid range";
59453289f6aSNate Lawson         Op->Asl.Value.Integer = HighValue;
59553289f6aSNate Lawson     }
59653289f6aSNate Lawson 
59753289f6aSNate Lawson     if (ParseError)
59853289f6aSNate Lawson     {
59953289f6aSNate Lawson         sprintf (Buffer, "%s 0x%X-0x%X", ParseError, LowValue, HighValue);
60053289f6aSNate Lawson         AslCompilererror (Buffer);
60153289f6aSNate Lawson 
60253289f6aSNate Lawson         return NULL;
60353289f6aSNate Lawson     }
60453289f6aSNate Lawson 
60553289f6aSNate Lawson     return Op;
60653289f6aSNate Lawson }
60753289f6aSNate Lawson 
60853289f6aSNate Lawson 
60953289f6aSNate Lawson /*******************************************************************************
61053289f6aSNate Lawson  *
61153289f6aSNate Lawson  * FUNCTION:    UtGetStringBuffer
61253289f6aSNate Lawson  *
61353289f6aSNate Lawson  * PARAMETERS:  Length          - Size of buffer requested
61453289f6aSNate Lawson  *
61553289f6aSNate Lawson  * RETURN:      Pointer to the buffer.  Aborts on allocation failure
61653289f6aSNate Lawson  *
61753289f6aSNate Lawson  * DESCRIPTION: Allocate a string buffer.  Bypass the local
61853289f6aSNate Lawson  *              dynamic memory manager for performance reasons (This has a
61953289f6aSNate Lawson  *              major impact on the speed of the compiler.)
62053289f6aSNate Lawson  *
62153289f6aSNate Lawson  ******************************************************************************/
62253289f6aSNate Lawson 
62353289f6aSNate Lawson char *
62453289f6aSNate Lawson UtGetStringBuffer (
62553289f6aSNate Lawson     UINT32                  Length)
62653289f6aSNate Lawson {
62753289f6aSNate Lawson     char                    *Buffer;
62853289f6aSNate Lawson 
62953289f6aSNate Lawson 
63053289f6aSNate Lawson     if ((Gbl_StringCacheNext + Length) >= Gbl_StringCacheLast)
63153289f6aSNate Lawson     {
63253289f6aSNate Lawson         Gbl_StringCacheNext = UtLocalCalloc (ASL_STRING_CACHE_SIZE + Length);
633fba7fc7eSJung-uk Kim         Gbl_StringCacheLast = Gbl_StringCacheNext + ASL_STRING_CACHE_SIZE +
634fba7fc7eSJung-uk Kim                                 Length;
63553289f6aSNate Lawson     }
63653289f6aSNate Lawson 
63753289f6aSNate Lawson     Buffer = Gbl_StringCacheNext;
63853289f6aSNate Lawson     Gbl_StringCacheNext += Length;
63953289f6aSNate Lawson 
64053289f6aSNate Lawson     return (Buffer);
64153289f6aSNate Lawson }
64253289f6aSNate Lawson 
64353289f6aSNate Lawson 
64453289f6aSNate Lawson /*******************************************************************************
64553289f6aSNate Lawson  *
64653289f6aSNate Lawson  * FUNCTION:    UtInternalizeName
64753289f6aSNate Lawson  *
64853289f6aSNate Lawson  * PARAMETERS:  ExternalName            - Name to convert
64953289f6aSNate Lawson  *              ConvertedName           - Where the converted name is returned
65053289f6aSNate Lawson  *
65153289f6aSNate Lawson  * RETURN:      Status
65253289f6aSNate Lawson  *
65353289f6aSNate Lawson  * DESCRIPTION: Convert an external (ASL) name to an internal (AML) name
65453289f6aSNate Lawson  *
65553289f6aSNate Lawson  ******************************************************************************/
65653289f6aSNate Lawson 
65753289f6aSNate Lawson ACPI_STATUS
65853289f6aSNate Lawson UtInternalizeName (
65953289f6aSNate Lawson     char                    *ExternalName,
66053289f6aSNate Lawson     char                    **ConvertedName)
66153289f6aSNate Lawson {
66253289f6aSNate Lawson     ACPI_NAMESTRING_INFO    Info;
66353289f6aSNate Lawson     ACPI_STATUS             Status;
66453289f6aSNate Lawson 
66553289f6aSNate Lawson 
66653289f6aSNate Lawson     if (!ExternalName)
66753289f6aSNate Lawson     {
66853289f6aSNate Lawson         return (AE_OK);
66953289f6aSNate Lawson     }
67053289f6aSNate Lawson 
67153289f6aSNate Lawson     /* Get the length of the new internal name */
67253289f6aSNate Lawson 
67353289f6aSNate Lawson     Info.ExternalName = ExternalName;
67453289f6aSNate Lawson     AcpiNsGetInternalNameLength (&Info);
67553289f6aSNate Lawson 
67653289f6aSNate Lawson     /* We need a segment to store the internal  name */
67753289f6aSNate Lawson 
67853289f6aSNate Lawson     Info.InternalName = UtGetStringBuffer (Info.Length);
67953289f6aSNate Lawson     if (!Info.InternalName)
68053289f6aSNate Lawson     {
68153289f6aSNate Lawson         return (AE_NO_MEMORY);
68253289f6aSNate Lawson     }
68353289f6aSNate Lawson 
68453289f6aSNate Lawson     /* Build the name */
68553289f6aSNate Lawson 
68653289f6aSNate Lawson     Status = AcpiNsBuildInternalName (&Info);
68753289f6aSNate Lawson     if (ACPI_FAILURE (Status))
68853289f6aSNate Lawson     {
68953289f6aSNate Lawson         return (Status);
69053289f6aSNate Lawson     }
69153289f6aSNate Lawson 
69253289f6aSNate Lawson     *ConvertedName = Info.InternalName;
69353289f6aSNate Lawson     return (AE_OK);
69453289f6aSNate Lawson }
69553289f6aSNate Lawson 
69653289f6aSNate Lawson 
69753289f6aSNate Lawson /*******************************************************************************
69853289f6aSNate Lawson  *
69953289f6aSNate Lawson  * FUNCTION:    UtPadNameWithUnderscores
70053289f6aSNate Lawson  *
70153289f6aSNate Lawson  * PARAMETERS:  NameSeg         - Input nameseg
70253289f6aSNate Lawson  *              PaddedNameSeg   - Output padded nameseg
70353289f6aSNate Lawson  *
70453289f6aSNate Lawson  * RETURN:      Padded nameseg.
70553289f6aSNate Lawson  *
70653289f6aSNate Lawson  * DESCRIPTION: Pads a NameSeg with underscores if necessary to form a full
70753289f6aSNate Lawson  *              ACPI_NAME.
70853289f6aSNate Lawson  *
70953289f6aSNate Lawson  ******************************************************************************/
71053289f6aSNate Lawson 
711fba7fc7eSJung-uk Kim static void
71253289f6aSNate Lawson UtPadNameWithUnderscores (
71353289f6aSNate Lawson     char                    *NameSeg,
71453289f6aSNate Lawson     char                    *PaddedNameSeg)
71553289f6aSNate Lawson {
71653289f6aSNate Lawson     UINT32                  i;
71753289f6aSNate Lawson 
71853289f6aSNate Lawson 
71953289f6aSNate Lawson     for (i = 0; (i < ACPI_NAME_SIZE); i++)
72053289f6aSNate Lawson     {
72153289f6aSNate Lawson         if (*NameSeg)
72253289f6aSNate Lawson         {
72353289f6aSNate Lawson             *PaddedNameSeg = *NameSeg;
72453289f6aSNate Lawson             NameSeg++;
72553289f6aSNate Lawson         }
72653289f6aSNate Lawson         else
72753289f6aSNate Lawson         {
72853289f6aSNate Lawson             *PaddedNameSeg = '_';
72953289f6aSNate Lawson         }
73053289f6aSNate Lawson         PaddedNameSeg++;
73153289f6aSNate Lawson     }
73253289f6aSNate Lawson }
73353289f6aSNate Lawson 
73453289f6aSNate Lawson 
73553289f6aSNate Lawson /*******************************************************************************
73653289f6aSNate Lawson  *
73753289f6aSNate Lawson  * FUNCTION:    UtAttachNameseg
73853289f6aSNate Lawson  *
73953289f6aSNate Lawson  * PARAMETERS:  Op              - Parent parse node
74053289f6aSNate Lawson  *              Name            - Full ExternalName
74153289f6aSNate Lawson  *
742fba7fc7eSJung-uk Kim  * RETURN:      None; Sets the NameSeg field in parent node
74353289f6aSNate Lawson  *
74453289f6aSNate Lawson  * DESCRIPTION: Extract the last nameseg of the ExternalName and store it
74553289f6aSNate Lawson  *              in the NameSeg field of the Op.
74653289f6aSNate Lawson  *
74753289f6aSNate Lawson  ******************************************************************************/
74853289f6aSNate Lawson 
749fba7fc7eSJung-uk Kim static void
75053289f6aSNate Lawson UtAttachNameseg (
75153289f6aSNate Lawson     ACPI_PARSE_OBJECT       *Op,
75253289f6aSNate Lawson     char                    *Name)
75353289f6aSNate Lawson {
75453289f6aSNate Lawson     char                    *NameSeg;
75553289f6aSNate Lawson     char                    PaddedNameSeg[4];
75653289f6aSNate Lawson 
75753289f6aSNate Lawson 
75853289f6aSNate Lawson     if (!Name)
75953289f6aSNate Lawson     {
76053289f6aSNate Lawson         return;
76153289f6aSNate Lawson     }
76253289f6aSNate Lawson 
76353289f6aSNate Lawson     /* Look for the last dot in the namepath */
76453289f6aSNate Lawson 
76553289f6aSNate Lawson     NameSeg = strrchr (Name, '.');
76653289f6aSNate Lawson     if (NameSeg)
76753289f6aSNate Lawson     {
76853289f6aSNate Lawson         /* Found last dot, we have also found the final nameseg */
76953289f6aSNate Lawson 
77053289f6aSNate Lawson         NameSeg++;
77153289f6aSNate Lawson         UtPadNameWithUnderscores (NameSeg, PaddedNameSeg);
77253289f6aSNate Lawson     }
77353289f6aSNate Lawson     else
77453289f6aSNate Lawson     {
77553289f6aSNate Lawson         /* No dots in the namepath, there is only a single nameseg. */
77653289f6aSNate Lawson         /* Handle prefixes */
77753289f6aSNate Lawson 
77853289f6aSNate Lawson         while ((*Name == '\\') || (*Name == '^'))
77953289f6aSNate Lawson         {
78053289f6aSNate Lawson             Name++;
78153289f6aSNate Lawson         }
78253289f6aSNate Lawson 
78353289f6aSNate Lawson         /* Remaing string should be one single nameseg */
78453289f6aSNate Lawson 
78553289f6aSNate Lawson         UtPadNameWithUnderscores (Name, PaddedNameSeg);
78653289f6aSNate Lawson     }
78753289f6aSNate Lawson 
78853289f6aSNate Lawson     strncpy (Op->Asl.NameSeg, PaddedNameSeg, 4);
78953289f6aSNate Lawson }
79053289f6aSNate Lawson 
79153289f6aSNate Lawson 
79253289f6aSNate Lawson /*******************************************************************************
79353289f6aSNate Lawson  *
79453289f6aSNate Lawson  * FUNCTION:    UtAttachNamepathToOwner
79553289f6aSNate Lawson  *
79653289f6aSNate Lawson  * PARAMETERS:  Op            - Parent parse node
79753289f6aSNate Lawson  *              NameOp        - Node that contains the name
79853289f6aSNate Lawson  *
79953289f6aSNate Lawson  * RETURN:      Sets the ExternalName and Namepath in the parent node
80053289f6aSNate Lawson  *
80153289f6aSNate Lawson  * DESCRIPTION: Store the name in two forms in the parent node:  The original
80253289f6aSNate Lawson  *              (external) name, and the internalized name that is used within
80353289f6aSNate Lawson  *              the ACPI namespace manager.
80453289f6aSNate Lawson  *
80553289f6aSNate Lawson  ******************************************************************************/
80653289f6aSNate Lawson 
80753289f6aSNate Lawson void
80853289f6aSNate Lawson UtAttachNamepathToOwner (
80953289f6aSNate Lawson     ACPI_PARSE_OBJECT       *Op,
81053289f6aSNate Lawson     ACPI_PARSE_OBJECT       *NameOp)
81153289f6aSNate Lawson {
81253289f6aSNate Lawson     ACPI_STATUS             Status;
81353289f6aSNate Lawson 
81453289f6aSNate Lawson 
81553289f6aSNate Lawson     /* Full external path */
81653289f6aSNate Lawson 
81753289f6aSNate Lawson     Op->Asl.ExternalName = NameOp->Asl.Value.String;
81853289f6aSNate Lawson 
819fba7fc7eSJung-uk Kim     /* Save the NameOp for possible error reporting later */
820fba7fc7eSJung-uk Kim 
821fba7fc7eSJung-uk Kim     Op->Asl.ParentMethod = (void *) NameOp;
822fba7fc7eSJung-uk Kim 
82353289f6aSNate Lawson     /* Last nameseg of the path */
82453289f6aSNate Lawson 
82553289f6aSNate Lawson     UtAttachNameseg (Op, Op->Asl.ExternalName);
82653289f6aSNate Lawson 
82753289f6aSNate Lawson     /* Create internalized path */
82853289f6aSNate Lawson 
82953289f6aSNate Lawson     Status = UtInternalizeName (NameOp->Asl.Value.String, &Op->Asl.Namepath);
83053289f6aSNate Lawson     if (ACPI_FAILURE (Status))
83153289f6aSNate Lawson     {
83253289f6aSNate Lawson         /* TBD: abort on no memory */
83353289f6aSNate Lawson     }
83453289f6aSNate Lawson }
83553289f6aSNate Lawson 
83653289f6aSNate Lawson 
83753289f6aSNate Lawson /*******************************************************************************
83853289f6aSNate Lawson  *
83953289f6aSNate Lawson  * FUNCTION:    UtDoConstant
84053289f6aSNate Lawson  *
84153289f6aSNate Lawson  * PARAMETERS:  String      - Hex, Octal, or Decimal string
84253289f6aSNate Lawson  *
84353289f6aSNate Lawson  * RETURN:      Converted Integer
84453289f6aSNate Lawson  *
84553289f6aSNate Lawson  * DESCRIPTION: Convert a string to an integer.  With error checking.
84653289f6aSNate Lawson  *
84753289f6aSNate Lawson  ******************************************************************************/
84853289f6aSNate Lawson 
8499a179dd8SJung-uk Kim UINT64
85053289f6aSNate Lawson UtDoConstant (
85153289f6aSNate Lawson     char                    *String)
85253289f6aSNate Lawson {
85353289f6aSNate Lawson     ACPI_STATUS             Status;
8549a179dd8SJung-uk Kim     UINT64                  Converted;
85553289f6aSNate Lawson     char                    ErrBuf[64];
85653289f6aSNate Lawson 
85753289f6aSNate Lawson 
85853289f6aSNate Lawson     Status = UtStrtoul64 (String, 0, &Converted);
85953289f6aSNate Lawson     if (ACPI_FAILURE (Status))
86053289f6aSNate Lawson     {
861fba7fc7eSJung-uk Kim         sprintf (ErrBuf, "%s %s\n", "Conversion error:",
862fba7fc7eSJung-uk Kim             AcpiFormatException (Status));
86353289f6aSNate Lawson         AslCompilererror (ErrBuf);
86453289f6aSNate Lawson     }
86553289f6aSNate Lawson 
86653289f6aSNate Lawson     return (Converted);
86753289f6aSNate Lawson }
86853289f6aSNate Lawson 
86953289f6aSNate Lawson 
870fba7fc7eSJung-uk Kim /* TBD: use version in ACPI CA main code base? */
871fba7fc7eSJung-uk Kim 
87253289f6aSNate Lawson /*******************************************************************************
87353289f6aSNate Lawson  *
87453289f6aSNate Lawson  * FUNCTION:    UtStrtoul64
87553289f6aSNate Lawson  *
87653289f6aSNate Lawson  * PARAMETERS:  String          - Null terminated string
877fba7fc7eSJung-uk Kim  *              Terminater      - Where a pointer to the terminating byte is
878fba7fc7eSJung-uk Kim  *                                returned
87953289f6aSNate Lawson  *              Base            - Radix of the string
88053289f6aSNate Lawson  *
88153289f6aSNate Lawson  * RETURN:      Converted value
88253289f6aSNate Lawson  *
88353289f6aSNate Lawson  * DESCRIPTION: Convert a string into an unsigned value.
88453289f6aSNate Lawson  *
88553289f6aSNate Lawson  ******************************************************************************/
88653289f6aSNate Lawson 
887fba7fc7eSJung-uk Kim static ACPI_STATUS
88853289f6aSNate Lawson UtStrtoul64 (
88953289f6aSNate Lawson     char                    *String,
89053289f6aSNate Lawson     UINT32                  Base,
8919a179dd8SJung-uk Kim     UINT64                  *RetInteger)
89253289f6aSNate Lawson {
89353289f6aSNate Lawson     UINT32                  Index;
89453289f6aSNate Lawson     UINT32                  Sign;
8959a179dd8SJung-uk Kim     UINT64                  ReturnValue = 0;
89653289f6aSNate Lawson     ACPI_STATUS             Status = AE_OK;
89753289f6aSNate Lawson 
89853289f6aSNate Lawson 
89953289f6aSNate Lawson     *RetInteger = 0;
90053289f6aSNate Lawson 
90153289f6aSNate Lawson     switch (Base)
90253289f6aSNate Lawson     {
90353289f6aSNate Lawson     case 0:
90453289f6aSNate Lawson     case 8:
90553289f6aSNate Lawson     case 10:
90653289f6aSNate Lawson     case 16:
90753289f6aSNate Lawson         break;
90853289f6aSNate Lawson 
90953289f6aSNate Lawson     default:
91053289f6aSNate Lawson         /*
91153289f6aSNate Lawson          * The specified Base parameter is not in the domain of
91253289f6aSNate Lawson          * this function:
91353289f6aSNate Lawson          */
91453289f6aSNate Lawson         return (AE_BAD_PARAMETER);
91553289f6aSNate Lawson     }
91653289f6aSNate Lawson 
917fba7fc7eSJung-uk Kim     /* Skip over any white space in the buffer: */
918fba7fc7eSJung-uk Kim 
9199a179dd8SJung-uk Kim     while (isspace ((int) *String) || *String == '\t')
92053289f6aSNate Lawson     {
92153289f6aSNate Lawson         ++String;
92253289f6aSNate Lawson     }
92353289f6aSNate Lawson 
92453289f6aSNate Lawson     /*
92553289f6aSNate Lawson      * The buffer may contain an optional plus or minus sign.
92653289f6aSNate Lawson      * If it does, then skip over it but remember what is was:
92753289f6aSNate Lawson      */
92853289f6aSNate Lawson     if (*String == '-')
92953289f6aSNate Lawson     {
93053289f6aSNate Lawson         Sign = NEGATIVE;
93153289f6aSNate Lawson         ++String;
93253289f6aSNate Lawson     }
93353289f6aSNate Lawson     else if (*String == '+')
93453289f6aSNate Lawson     {
93553289f6aSNate Lawson         ++String;
93653289f6aSNate Lawson         Sign = POSITIVE;
93753289f6aSNate Lawson     }
93853289f6aSNate Lawson     else
93953289f6aSNate Lawson     {
94053289f6aSNate Lawson         Sign = POSITIVE;
94153289f6aSNate Lawson     }
94253289f6aSNate Lawson 
94353289f6aSNate Lawson     /*
94453289f6aSNate Lawson      * If the input parameter Base is zero, then we need to
94553289f6aSNate Lawson      * determine if it is octal, decimal, or hexadecimal:
94653289f6aSNate Lawson      */
94753289f6aSNate Lawson     if (Base == 0)
94853289f6aSNate Lawson     {
94953289f6aSNate Lawson         if (*String == '0')
95053289f6aSNate Lawson         {
9519a179dd8SJung-uk Kim             if (tolower ((int) *(++String)) == 'x')
95253289f6aSNate Lawson             {
95353289f6aSNate Lawson                 Base = 16;
95453289f6aSNate Lawson                 ++String;
95553289f6aSNate Lawson             }
95653289f6aSNate Lawson             else
95753289f6aSNate Lawson             {
95853289f6aSNate Lawson                 Base = 8;
95953289f6aSNate Lawson             }
96053289f6aSNate Lawson         }
96153289f6aSNate Lawson         else
96253289f6aSNate Lawson         {
96353289f6aSNate Lawson             Base = 10;
96453289f6aSNate Lawson         }
96553289f6aSNate Lawson     }
96653289f6aSNate Lawson 
96753289f6aSNate Lawson     /*
96853289f6aSNate Lawson      * For octal and hexadecimal bases, skip over the leading
96953289f6aSNate Lawson      * 0 or 0x, if they are present.
97053289f6aSNate Lawson      */
97153289f6aSNate Lawson     if (Base == 8 && *String == '0')
97253289f6aSNate Lawson     {
97353289f6aSNate Lawson         String++;
97453289f6aSNate Lawson     }
97553289f6aSNate Lawson 
97653289f6aSNate Lawson     if (Base == 16 &&
97753289f6aSNate Lawson         *String == '0' &&
9789a179dd8SJung-uk Kim         tolower ((int) *(++String)) == 'x')
97953289f6aSNate Lawson     {
98053289f6aSNate Lawson         String++;
98153289f6aSNate Lawson     }
98253289f6aSNate Lawson 
98353289f6aSNate Lawson     /* Main loop: convert the string to an unsigned long */
98453289f6aSNate Lawson 
98553289f6aSNate Lawson     while (*String)
98653289f6aSNate Lawson     {
9879a179dd8SJung-uk Kim         if (isdigit ((int) *String))
98853289f6aSNate Lawson         {
98953289f6aSNate Lawson             Index = ((UINT8) *String) - '0';
99053289f6aSNate Lawson         }
99153289f6aSNate Lawson         else
99253289f6aSNate Lawson         {
9939a179dd8SJung-uk Kim             Index = (UINT8) toupper ((int) *String);
9949a179dd8SJung-uk Kim             if (isupper ((int) Index))
99553289f6aSNate Lawson             {
99653289f6aSNate Lawson                 Index = Index - 'A' + 10;
99753289f6aSNate Lawson             }
99853289f6aSNate Lawson             else
99953289f6aSNate Lawson             {
100053289f6aSNate Lawson                 goto ErrorExit;
100153289f6aSNate Lawson             }
100253289f6aSNate Lawson         }
100353289f6aSNate Lawson 
100453289f6aSNate Lawson         if (Index >= Base)
100553289f6aSNate Lawson         {
100653289f6aSNate Lawson             goto ErrorExit;
100753289f6aSNate Lawson         }
100853289f6aSNate Lawson 
100953289f6aSNate Lawson         /* Check to see if value is out of range: */
101053289f6aSNate Lawson 
10119a179dd8SJung-uk Kim         if (ReturnValue > ((ACPI_UINT64_MAX - (UINT64) Index) /
10129a179dd8SJung-uk Kim                             (UINT64) Base))
101353289f6aSNate Lawson         {
101453289f6aSNate Lawson             goto ErrorExit;
101553289f6aSNate Lawson         }
101653289f6aSNate Lawson         else
101753289f6aSNate Lawson         {
101853289f6aSNate Lawson             ReturnValue *= Base;
101953289f6aSNate Lawson             ReturnValue += Index;
102053289f6aSNate Lawson         }
102153289f6aSNate Lawson 
102253289f6aSNate Lawson         ++String;
102353289f6aSNate Lawson     }
102453289f6aSNate Lawson 
102553289f6aSNate Lawson 
1026fba7fc7eSJung-uk Kim     /* If a minus sign was present, then "the conversion is negated": */
1027fba7fc7eSJung-uk Kim 
102853289f6aSNate Lawson     if (Sign == NEGATIVE)
102953289f6aSNate Lawson     {
103053289f6aSNate Lawson         ReturnValue = (ACPI_UINT32_MAX - ReturnValue) + 1;
103153289f6aSNate Lawson     }
103253289f6aSNate Lawson 
103353289f6aSNate Lawson     *RetInteger = ReturnValue;
103453289f6aSNate Lawson     return (Status);
103553289f6aSNate Lawson 
103653289f6aSNate Lawson 
103753289f6aSNate Lawson ErrorExit:
103853289f6aSNate Lawson     switch (Base)
103953289f6aSNate Lawson     {
104053289f6aSNate Lawson     case 8:
104153289f6aSNate Lawson         Status = AE_BAD_OCTAL_CONSTANT;
104253289f6aSNate Lawson         break;
104353289f6aSNate Lawson 
104453289f6aSNate Lawson     case 10:
104553289f6aSNate Lawson         Status = AE_BAD_DECIMAL_CONSTANT;
104653289f6aSNate Lawson         break;
104753289f6aSNate Lawson 
104853289f6aSNate Lawson     case 16:
104953289f6aSNate Lawson         Status = AE_BAD_HEX_CONSTANT;
105053289f6aSNate Lawson         break;
105153289f6aSNate Lawson 
105253289f6aSNate Lawson     default:
105353289f6aSNate Lawson         /* Base validated above */
105453289f6aSNate Lawson         break;
105553289f6aSNate Lawson     }
105653289f6aSNate Lawson 
105753289f6aSNate Lawson     return (Status);
105853289f6aSNate Lawson }
105953289f6aSNate Lawson 
106053289f6aSNate Lawson 
1061