Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /******************************************************************************
  2.  *
  3.  * Module Name: psscope - Parser scope stack management routines
  4.  *
  5.  *****************************************************************************/
  6.  
  7. /******************************************************************************
  8.  *
  9.  * 1. Copyright Notice
  10.  *
  11.  * Some or all of this work - Copyright (c) 1999 - 2010, Intel Corp.
  12.  * All rights reserved.
  13.  *
  14.  * 2. License
  15.  *
  16.  * 2.1. This is your license from Intel Corp. under its intellectual property
  17.  * rights.  You may have additional license terms from the party that provided
  18.  * you this software, covering your right to use that party's intellectual
  19.  * property rights.
  20.  *
  21.  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  22.  * copy of the source code appearing in this file ("Covered Code") an
  23.  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  24.  * base code distributed originally by Intel ("Original Intel Code") to copy,
  25.  * make derivatives, distribute, use and display any portion of the Covered
  26.  * Code in any form, with the right to sublicense such rights; and
  27.  *
  28.  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  29.  * license (with the right to sublicense), under only those claims of Intel
  30.  * patents that are infringed by the Original Intel Code, to make, use, sell,
  31.  * offer to sell, and import the Covered Code and derivative works thereof
  32.  * solely to the minimum extent necessary to exercise the above copyright
  33.  * license, and in no event shall the patent license extend to any additions
  34.  * to or modifications of the Original Intel Code.  No other license or right
  35.  * is granted directly or by implication, estoppel or otherwise;
  36.  *
  37.  * The above copyright and patent license is granted only if the following
  38.  * conditions are met:
  39.  *
  40.  * 3. Conditions
  41.  *
  42.  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  43.  * Redistribution of source code of any substantial portion of the Covered
  44.  * Code or modification with rights to further distribute source must include
  45.  * the above Copyright Notice, the above License, this list of Conditions,
  46.  * and the following Disclaimer and Export Compliance provision.  In addition,
  47.  * Licensee must cause all Covered Code to which Licensee contributes to
  48.  * contain a file documenting the changes Licensee made to create that Covered
  49.  * Code and the date of any change.  Licensee must include in that file the
  50.  * documentation of any changes made by any predecessor Licensee.  Licensee
  51.  * must include a prominent statement that the modification is derived,
  52.  * directly or indirectly, from Original Intel Code.
  53.  *
  54.  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  55.  * Redistribution of source code of any substantial portion of the Covered
  56.  * Code or modification without rights to further distribute source must
  57.  * include the following Disclaimer and Export Compliance provision in the
  58.  * documentation and/or other materials provided with distribution.  In
  59.  * addition, Licensee may not authorize further sublicense of source of any
  60.  * portion of the Covered Code, and must include terms to the effect that the
  61.  * license from Licensee to its licensee is limited to the intellectual
  62.  * property embodied in the software Licensee provides to its licensee, and
  63.  * not to intellectual property embodied in modifications its licensee may
  64.  * make.
  65.  *
  66.  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  67.  * substantial portion of the Covered Code or modification must reproduce the
  68.  * above Copyright Notice, and the following Disclaimer and Export Compliance
  69.  * provision in the documentation and/or other materials provided with the
  70.  * distribution.
  71.  *
  72.  * 3.4. Intel retains all right, title, and interest in and to the Original
  73.  * Intel Code.
  74.  *
  75.  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  76.  * Intel shall be used in advertising or otherwise to promote the sale, use or
  77.  * other dealings in products derived from or relating to the Covered Code
  78.  * without prior written authorization from Intel.
  79.  *
  80.  * 4. Disclaimer and Export Compliance
  81.  *
  82.  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  83.  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  84.  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  85.  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  86.  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  87.  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  88.  * PARTICULAR PURPOSE.
  89.  *
  90.  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  91.  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  92.  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  93.  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  94.  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  95.  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  96.  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  97.  * LIMITED REMEDY.
  98.  *
  99.  * 4.3. Licensee shall not export, either directly or indirectly, any of this
  100.  * software or system incorporating such software without first obtaining any
  101.  * required license or other approval from the U. S. Department of Commerce or
  102.  * any other agency or department of the United States Government.  In the
  103.  * event Licensee exports any such software from the United States or
  104.  * re-exports any such software from a foreign destination, Licensee shall
  105.  * ensure that the distribution and export/re-export of the software is in
  106.  * compliance with all laws, regulations, orders, or other restrictions of the
  107.  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
  108.  * any of its subsidiaries will export/re-export any technical data, process,
  109.  * software, or service, directly or indirectly, to any country for which the
  110.  * United States government or any agency thereof requires an export license,
  111.  * other governmental approval, or letter of assurance, without first obtaining
  112.  * such license, approval or letter.
  113.  *
  114.  *****************************************************************************/
  115.  
  116.  
  117. #include "acpi.h"
  118. #include "accommon.h"
  119. #include "acparser.h"
  120.  
  121. #define _COMPONENT          ACPI_PARSER
  122.         ACPI_MODULE_NAME    ("psscope")
  123.  
  124.  
  125. /*******************************************************************************
  126.  *
  127.  * FUNCTION:    AcpiPsGetParentScope
  128.  *
  129.  * PARAMETERS:  ParserState         - Current parser state object
  130.  *
  131.  * RETURN:      Pointer to an Op object
  132.  *
  133.  * DESCRIPTION: Get parent of current op being parsed
  134.  *
  135.  ******************************************************************************/
  136.  
  137. ACPI_PARSE_OBJECT *
  138. AcpiPsGetParentScope (
  139.     ACPI_PARSE_STATE        *ParserState)
  140. {
  141.  
  142.     return (ParserState->Scope->ParseScope.Op);
  143. }
  144.  
  145.  
  146. /*******************************************************************************
  147.  *
  148.  * FUNCTION:    AcpiPsHasCompletedScope
  149.  *
  150.  * PARAMETERS:  ParserState         - Current parser state object
  151.  *
  152.  * RETURN:      Boolean, TRUE = scope completed.
  153.  *
  154.  * DESCRIPTION: Is parsing of current argument complete?  Determined by
  155.  *              1) AML pointer is at or beyond the end of the scope
  156.  *              2) The scope argument count has reached zero.
  157.  *
  158.  ******************************************************************************/
  159.  
  160. BOOLEAN
  161. AcpiPsHasCompletedScope (
  162.     ACPI_PARSE_STATE        *ParserState)
  163. {
  164.  
  165.     return ((BOOLEAN)
  166.             ((ParserState->Aml >= ParserState->Scope->ParseScope.ArgEnd ||
  167.              !ParserState->Scope->ParseScope.ArgCount)));
  168. }
  169.  
  170.  
  171. /*******************************************************************************
  172.  *
  173.  * FUNCTION:    AcpiPsInitScope
  174.  *
  175.  * PARAMETERS:  ParserState         - Current parser state object
  176.  *              Root                - the Root Node of this new scope
  177.  *
  178.  * RETURN:      Status
  179.  *
  180.  * DESCRIPTION: Allocate and init a new scope object
  181.  *
  182.  ******************************************************************************/
  183.  
  184. ACPI_STATUS
  185. AcpiPsInitScope (
  186.     ACPI_PARSE_STATE        *ParserState,
  187.     ACPI_PARSE_OBJECT       *RootOp)
  188. {
  189.     ACPI_GENERIC_STATE      *Scope;
  190.  
  191.  
  192.     ACPI_FUNCTION_TRACE_PTR (PsInitScope, RootOp);
  193.  
  194.  
  195.     Scope = AcpiUtCreateGenericState ();
  196.     if (!Scope)
  197.     {
  198.         return_ACPI_STATUS (AE_NO_MEMORY);
  199.     }
  200.  
  201.     Scope->Common.DescriptorType = ACPI_DESC_TYPE_STATE_RPSCOPE;
  202.     Scope->ParseScope.Op = RootOp;
  203.     Scope->ParseScope.ArgCount = ACPI_VAR_ARGS;
  204.     Scope->ParseScope.ArgEnd = ParserState->AmlEnd;
  205.     Scope->ParseScope.PkgEnd = ParserState->AmlEnd;
  206.  
  207.     ParserState->Scope = Scope;
  208.     ParserState->StartOp = RootOp;
  209.  
  210.     return_ACPI_STATUS (AE_OK);
  211. }
  212.  
  213.  
  214. /*******************************************************************************
  215.  *
  216.  * FUNCTION:    AcpiPsPushScope
  217.  *
  218.  * PARAMETERS:  ParserState         - Current parser state object
  219.  *              Op                  - Current op to be pushed
  220.  *              RemainingArgs       - List of args remaining
  221.  *              ArgCount            - Fixed or variable number of args
  222.  *
  223.  * RETURN:      Status
  224.  *
  225.  * DESCRIPTION: Push current op to begin parsing its argument
  226.  *
  227.  ******************************************************************************/
  228.  
  229. ACPI_STATUS
  230. AcpiPsPushScope (
  231.     ACPI_PARSE_STATE        *ParserState,
  232.     ACPI_PARSE_OBJECT       *Op,
  233.     UINT32                  RemainingArgs,
  234.     UINT32                  ArgCount)
  235. {
  236.     ACPI_GENERIC_STATE      *Scope;
  237.  
  238.  
  239.     ACPI_FUNCTION_TRACE_PTR (PsPushScope, Op);
  240.  
  241.  
  242.     Scope = AcpiUtCreateGenericState ();
  243.     if (!Scope)
  244.     {
  245.         return_ACPI_STATUS (AE_NO_MEMORY);
  246.     }
  247.  
  248.     Scope->Common.DescriptorType = ACPI_DESC_TYPE_STATE_PSCOPE;
  249.     Scope->ParseScope.Op = Op;
  250.     Scope->ParseScope.ArgList = RemainingArgs;
  251.     Scope->ParseScope.ArgCount = ArgCount;
  252.     Scope->ParseScope.PkgEnd = ParserState->PkgEnd;
  253.  
  254.     /* Push onto scope stack */
  255.  
  256.     AcpiUtPushGenericState (&ParserState->Scope, Scope);
  257.  
  258.     if (ArgCount == ACPI_VAR_ARGS)
  259.     {
  260.         /* Multiple arguments */
  261.  
  262.         Scope->ParseScope.ArgEnd = ParserState->PkgEnd;
  263.     }
  264.     else
  265.     {
  266.         /* Single argument */
  267.  
  268.         Scope->ParseScope.ArgEnd = ACPI_TO_POINTER (ACPI_MAX_PTR);
  269.     }
  270.  
  271.     return_ACPI_STATUS (AE_OK);
  272. }
  273.  
  274.  
  275. /*******************************************************************************
  276.  *
  277.  * FUNCTION:    AcpiPsPopScope
  278.  *
  279.  * PARAMETERS:  ParserState         - Current parser state object
  280.  *              Op                  - Where the popped op is returned
  281.  *              ArgList             - Where the popped "next argument" is
  282.  *                                    returned
  283.  *              ArgCount            - Count of objects in ArgList
  284.  *
  285.  * RETURN:      Status
  286.  *
  287.  * DESCRIPTION: Return to parsing a previous op
  288.  *
  289.  ******************************************************************************/
  290.  
  291. void
  292. AcpiPsPopScope (
  293.     ACPI_PARSE_STATE        *ParserState,
  294.     ACPI_PARSE_OBJECT       **Op,
  295.     UINT32                  *ArgList,
  296.     UINT32                  *ArgCount)
  297. {
  298.     ACPI_GENERIC_STATE      *Scope = ParserState->Scope;
  299.  
  300.  
  301.     ACPI_FUNCTION_TRACE (PsPopScope);
  302.  
  303.  
  304.     /* Only pop the scope if there is in fact a next scope */
  305.  
  306.     if (Scope->Common.Next)
  307.     {
  308.         Scope = AcpiUtPopGenericState (&ParserState->Scope);
  309.  
  310.         /* Return to parsing previous op */
  311.  
  312.         *Op                 = Scope->ParseScope.Op;
  313.         *ArgList            = Scope->ParseScope.ArgList;
  314.         *ArgCount           = Scope->ParseScope.ArgCount;
  315.         ParserState->PkgEnd = Scope->ParseScope.PkgEnd;
  316.  
  317.         /* All done with this scope state structure */
  318.  
  319.         AcpiUtDeleteGenericState (Scope);
  320.     }
  321.     else
  322.     {
  323.         /* Empty parse stack, prepare to fetch next opcode */
  324.  
  325.         *Op       = NULL;
  326.         *ArgList  = 0;
  327.         *ArgCount = 0;
  328.     }
  329.  
  330.     ACPI_DEBUG_PRINT ((ACPI_DB_PARSE,
  331.         "Popped Op %p Args %X\n", *Op, *ArgCount));
  332.     return_VOID;
  333. }
  334.  
  335.  
  336. /*******************************************************************************
  337.  *
  338.  * FUNCTION:    AcpiPsCleanupScope
  339.  *
  340.  * PARAMETERS:  ParserState         - Current parser state object
  341.  *
  342.  * RETURN:      None
  343.  *
  344.  * DESCRIPTION: Destroy available list, remaining stack levels, and return
  345.  *              root scope
  346.  *
  347.  ******************************************************************************/
  348.  
  349. void
  350. AcpiPsCleanupScope (
  351.     ACPI_PARSE_STATE        *ParserState)
  352. {
  353.     ACPI_GENERIC_STATE      *Scope;
  354.  
  355.  
  356.     ACPI_FUNCTION_TRACE_PTR (PsCleanupScope, ParserState);
  357.  
  358.  
  359.     if (!ParserState)
  360.     {
  361.         return_VOID;
  362.     }
  363.  
  364.     /* Delete anything on the scope stack */
  365.  
  366.     while (ParserState->Scope)
  367.     {
  368.         Scope = AcpiUtPopGenericState (&ParserState->Scope);
  369.         AcpiUtDeleteGenericState (Scope);
  370.     }
  371.  
  372.     return_VOID;
  373. }
  374.  
  375.