1 /****************************************************************************** 2 * 3 * Module Name: psscope - Parser scope stack management routines 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2014, Intel Corp. 9 * All rights reserved. 10 * 11 * Redistribution and use in source and binary forms, with or without 12 * modification, are permitted provided that the following conditions 13 * are met: 14 * 1. Redistributions of source code must retain the above copyright 15 * notice, this list of conditions, and the following disclaimer, 16 * without modification. 17 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18 * substantially similar to the "NO WARRANTY" disclaimer below 19 * ("Disclaimer") and any redistribution must be conditioned upon 20 * including a substantially similar Disclaimer requirement for further 21 * binary redistribution. 22 * 3. Neither the names of the above-listed copyright holders nor the names 23 * of any contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * Alternatively, this software may be distributed under the terms of the 27 * GNU General Public License ("GPL") version 2 as published by the Free 28 * Software Foundation. 29 * 30 * NO WARRANTY 31 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41 * POSSIBILITY OF SUCH DAMAGES. 42 */ 43 44 #include <contrib/dev/acpica/include/acpi.h> 45 #include <contrib/dev/acpica/include/accommon.h> 46 #include <contrib/dev/acpica/include/acparser.h> 47 48 #define _COMPONENT ACPI_PARSER 49 ACPI_MODULE_NAME ("psscope") 50 51 52 /******************************************************************************* 53 * 54 * FUNCTION: AcpiPsGetParentScope 55 * 56 * PARAMETERS: ParserState - Current parser state object 57 * 58 * RETURN: Pointer to an Op object 59 * 60 * DESCRIPTION: Get parent of current op being parsed 61 * 62 ******************************************************************************/ 63 64 ACPI_PARSE_OBJECT * 65 AcpiPsGetParentScope ( 66 ACPI_PARSE_STATE *ParserState) 67 { 68 69 return (ParserState->Scope->ParseScope.Op); 70 } 71 72 73 /******************************************************************************* 74 * 75 * FUNCTION: AcpiPsHasCompletedScope 76 * 77 * PARAMETERS: ParserState - Current parser state object 78 * 79 * RETURN: Boolean, TRUE = scope completed. 80 * 81 * DESCRIPTION: Is parsing of current argument complete? Determined by 82 * 1) AML pointer is at or beyond the end of the scope 83 * 2) The scope argument count has reached zero. 84 * 85 ******************************************************************************/ 86 87 BOOLEAN 88 AcpiPsHasCompletedScope ( 89 ACPI_PARSE_STATE *ParserState) 90 { 91 92 return ((BOOLEAN) 93 ((ParserState->Aml >= ParserState->Scope->ParseScope.ArgEnd || 94 !ParserState->Scope->ParseScope.ArgCount))); 95 } 96 97 98 /******************************************************************************* 99 * 100 * FUNCTION: AcpiPsInitScope 101 * 102 * PARAMETERS: ParserState - Current parser state object 103 * Root - the Root Node of this new scope 104 * 105 * RETURN: Status 106 * 107 * DESCRIPTION: Allocate and init a new scope object 108 * 109 ******************************************************************************/ 110 111 ACPI_STATUS 112 AcpiPsInitScope ( 113 ACPI_PARSE_STATE *ParserState, 114 ACPI_PARSE_OBJECT *RootOp) 115 { 116 ACPI_GENERIC_STATE *Scope; 117 118 119 ACPI_FUNCTION_TRACE_PTR (PsInitScope, RootOp); 120 121 122 Scope = AcpiUtCreateGenericState (); 123 if (!Scope) 124 { 125 return_ACPI_STATUS (AE_NO_MEMORY); 126 } 127 128 Scope->Common.DescriptorType = ACPI_DESC_TYPE_STATE_RPSCOPE; 129 Scope->ParseScope.Op = RootOp; 130 Scope->ParseScope.ArgCount = ACPI_VAR_ARGS; 131 Scope->ParseScope.ArgEnd = ParserState->AmlEnd; 132 Scope->ParseScope.PkgEnd = ParserState->AmlEnd; 133 134 ParserState->Scope = Scope; 135 ParserState->StartOp = RootOp; 136 137 return_ACPI_STATUS (AE_OK); 138 } 139 140 141 /******************************************************************************* 142 * 143 * FUNCTION: AcpiPsPushScope 144 * 145 * PARAMETERS: ParserState - Current parser state object 146 * Op - Current op to be pushed 147 * RemainingArgs - List of args remaining 148 * ArgCount - Fixed or variable number of args 149 * 150 * RETURN: Status 151 * 152 * DESCRIPTION: Push current op to begin parsing its argument 153 * 154 ******************************************************************************/ 155 156 ACPI_STATUS 157 AcpiPsPushScope ( 158 ACPI_PARSE_STATE *ParserState, 159 ACPI_PARSE_OBJECT *Op, 160 UINT32 RemainingArgs, 161 UINT32 ArgCount) 162 { 163 ACPI_GENERIC_STATE *Scope; 164 165 166 ACPI_FUNCTION_TRACE_PTR (PsPushScope, Op); 167 168 169 Scope = AcpiUtCreateGenericState (); 170 if (!Scope) 171 { 172 return_ACPI_STATUS (AE_NO_MEMORY); 173 } 174 175 Scope->Common.DescriptorType = ACPI_DESC_TYPE_STATE_PSCOPE; 176 Scope->ParseScope.Op = Op; 177 Scope->ParseScope.ArgList = RemainingArgs; 178 Scope->ParseScope.ArgCount = ArgCount; 179 Scope->ParseScope.PkgEnd = ParserState->PkgEnd; 180 181 /* Push onto scope stack */ 182 183 AcpiUtPushGenericState (&ParserState->Scope, Scope); 184 185 if (ArgCount == ACPI_VAR_ARGS) 186 { 187 /* Multiple arguments */ 188 189 Scope->ParseScope.ArgEnd = ParserState->PkgEnd; 190 } 191 else 192 { 193 /* Single argument */ 194 195 Scope->ParseScope.ArgEnd = ACPI_TO_POINTER (ACPI_MAX_PTR); 196 } 197 198 return_ACPI_STATUS (AE_OK); 199 } 200 201 202 /******************************************************************************* 203 * 204 * FUNCTION: AcpiPsPopScope 205 * 206 * PARAMETERS: ParserState - Current parser state object 207 * Op - Where the popped op is returned 208 * ArgList - Where the popped "next argument" is 209 * returned 210 * ArgCount - Count of objects in ArgList 211 * 212 * RETURN: Status 213 * 214 * DESCRIPTION: Return to parsing a previous op 215 * 216 ******************************************************************************/ 217 218 void 219 AcpiPsPopScope ( 220 ACPI_PARSE_STATE *ParserState, 221 ACPI_PARSE_OBJECT **Op, 222 UINT32 *ArgList, 223 UINT32 *ArgCount) 224 { 225 ACPI_GENERIC_STATE *Scope = ParserState->Scope; 226 227 228 ACPI_FUNCTION_TRACE (PsPopScope); 229 230 231 /* Only pop the scope if there is in fact a next scope */ 232 233 if (Scope->Common.Next) 234 { 235 Scope = AcpiUtPopGenericState (&ParserState->Scope); 236 237 /* Return to parsing previous op */ 238 239 *Op = Scope->ParseScope.Op; 240 *ArgList = Scope->ParseScope.ArgList; 241 *ArgCount = Scope->ParseScope.ArgCount; 242 ParserState->PkgEnd = Scope->ParseScope.PkgEnd; 243 244 /* All done with this scope state structure */ 245 246 AcpiUtDeleteGenericState (Scope); 247 } 248 else 249 { 250 /* Empty parse stack, prepare to fetch next opcode */ 251 252 *Op = NULL; 253 *ArgList = 0; 254 *ArgCount = 0; 255 } 256 257 ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, 258 "Popped Op %p Args %X\n", *Op, *ArgCount)); 259 return_VOID; 260 } 261 262 263 /******************************************************************************* 264 * 265 * FUNCTION: AcpiPsCleanupScope 266 * 267 * PARAMETERS: ParserState - Current parser state object 268 * 269 * RETURN: None 270 * 271 * DESCRIPTION: Destroy available list, remaining stack levels, and return 272 * root scope 273 * 274 ******************************************************************************/ 275 276 void 277 AcpiPsCleanupScope ( 278 ACPI_PARSE_STATE *ParserState) 279 { 280 ACPI_GENERIC_STATE *Scope; 281 282 283 ACPI_FUNCTION_TRACE_PTR (PsCleanupScope, ParserState); 284 285 286 if (!ParserState) 287 { 288 return_VOID; 289 } 290 291 /* Delete anything on the scope stack */ 292 293 while (ParserState->Scope) 294 { 295 Scope = AcpiUtPopGenericState (&ParserState->Scope); 296 AcpiUtDeleteGenericState (Scope); 297 } 298 299 return_VOID; 300 } 301