acpica-unix2-20130823
PANKOVs restructure

          --- old/usr/src/uts/intel/io/acpica/parser/pswalk.c
          +++ new/usr/src/common/acpica/components/parser/pswalk.c
   1    1  /******************************************************************************
   2    2   *
   3    3   * Module Name: pswalk - Parser routines to walk parsed op tree(s)
   4    4   *
   5    5   *****************************************************************************/
   6    6  
   7    7  /*
   8      - * Copyright (C) 2000 - 2011, Intel Corp.
        8 + * Copyright (C) 2000 - 2013, Intel Corp.
   9    9   * All rights reserved.
  10   10   *
  11   11   * Redistribution and use in source and binary forms, with or without
  12   12   * modification, are permitted provided that the following conditions
  13   13   * are met:
  14   14   * 1. Redistributions of source code must retain the above copyright
  15   15   *    notice, this list of conditions, and the following disclaimer,
  16   16   *    without modification.
  17   17   * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18   18   *    substantially similar to the "NO WARRANTY" disclaimer below

  19   19   *    ("Disclaimer") and any redistribution must be conditioned upon
  20   20   *    including a substantially similar Disclaimer requirement for further
  21   21   *    binary redistribution.
  22   22   * 3. Neither the names of the above-listed copyright holders nor the names
  23   23   *    of any contributors may be used to endorse or promote products derived
  24   24   *    from this software without specific prior written permission.
  25   25   *
  26   26   * Alternatively, this software may be distributed under the terms of the
  27   27   * GNU General Public License ("GPL") version 2 as published by the Free
  28   28   * Software Foundation.
  29   29   *
  30   30   * NO WARRANTY
  31   31   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32   32   * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33   33   * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34   34   * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35   35   * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36   36   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37   37   * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38   38   * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39   39   * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40   40   * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41   41   * POSSIBILITY OF SUCH DAMAGES.
  42   42   */
  43   43  
  44   44  
  45   45  #include "acpi.h"
  46   46  #include "accommon.h"
  47   47  #include "acparser.h"
  48   48  
  49   49  #define _COMPONENT          ACPI_PARSER
  50   50          ACPI_MODULE_NAME    ("pswalk")
  51   51  
  52   52  
  53   53  /*******************************************************************************
  54   54   *
  55   55   * FUNCTION:    AcpiPsDeleteParseTree
  56   56   *
  57   57   * PARAMETERS:  SubtreeRoot         - Root of tree (or subtree) to delete
  58   58   *
  59   59   * RETURN:      None
  60   60   *
  61   61   * DESCRIPTION: Delete a portion of or an entire parse tree.
  62   62   *
  63   63   ******************************************************************************/
  64   64  
  65   65  void
  66   66  AcpiPsDeleteParseTree (
  67   67      ACPI_PARSE_OBJECT       *SubtreeRoot)
  68   68  {
  69   69      ACPI_PARSE_OBJECT       *Op = SubtreeRoot;
  70   70      ACPI_PARSE_OBJECT       *Next = NULL;
  71   71      ACPI_PARSE_OBJECT       *Parent = NULL;
  72   72  
  73   73  
  74   74      ACPI_FUNCTION_TRACE_PTR (PsDeleteParseTree, SubtreeRoot);
  75   75  
  76   76  
  77   77      /* Visit all nodes in the subtree */
  78   78  
  79   79      while (Op)
  80   80      {
  81   81          /* Check if we are not ascending */
  82   82  
  83   83          if (Op != Parent)
  84   84          {
  85   85              /* Look for an argument or child of the current op */
  86   86  
  87   87              Next = AcpiPsGetArg (Op, 0);
  88   88              if (Next)
  89   89              {
  90   90                  /* Still going downward in tree (Op is not completed yet) */
  91   91  
  92   92                  Op = Next;
  93   93                  continue;
  94   94              }
  95   95          }
  96   96  
  97   97          /* No more children, this Op is complete. */
  98   98  
  99   99          Next = Op->Common.Next;
 100  100          Parent = Op->Common.Parent;
 101  101  
 102  102          AcpiPsFreeOp (Op);
 103  103  
 104  104          /* If we are back to the starting point, the walk is complete. */
 105  105  
 106  106          if (Op == SubtreeRoot)
 107  107          {
 108  108              return_VOID;
 109  109          }
 110  110          if (Next)
 111  111          {
 112  112              Op = Next;
 113  113          }
 114  114          else
 115  115          {
 116  116              Op = Parent;
 117  117          }
 118  118      }
 119  119  
 120  120      return_VOID;
 121  121  }

XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX