aslrules.y revision 1.1.1.8
1 NoEcho(' 2 /****************************************************************************** 3 * 4 * Module Name: aslrules.y - Main Bison/Yacc production rules 5 * - Keep this file synched with the 6 * CvParseOpBlockType function in cvcompiler.c 7 * 8 *****************************************************************************/ 9 10 /* 11 * Copyright (C) 2000 - 2017, Intel Corp. 12 * All rights reserved. 13 * 14 * Redistribution and use in source and binary forms, with or without 15 * modification, are permitted provided that the following conditions 16 * are met: 17 * 1. Redistributions of source code must retain the above copyright 18 * notice, this list of conditions, and the following disclaimer, 19 * without modification. 20 * 2. Redistributions in binary form must reproduce at minimum a disclaimer 21 * substantially similar to the "NO WARRANTY" disclaimer below 22 * ("Disclaimer") and any redistribution must be conditioned upon 23 * including a substantially similar Disclaimer requirement for further 24 * binary redistribution. 25 * 3. Neither the names of the above-listed copyright holders nor the names 26 * of any contributors may be used to endorse or promote products derived 27 * from this software without specific prior written permission. 28 * 29 * Alternatively, this software may be distributed under the terms of the 30 * GNU General Public License ("GPL") version 2 as published by the Free 31 * Software Foundation. 32 * 33 * NO WARRANTY 34 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 35 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 36 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 37 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 38 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 39 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 40 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 41 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 42 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 43 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 44 * POSSIBILITY OF SUCH DAMAGES. 45 */ 46 47 ') 48 49 /******************************************************************************* 50 * 51 * ASL Root and Secondary Terms 52 * 53 ******************************************************************************/ 54 55 /* 56 * Root term. Allow multiple #line directives before the definition block 57 * to handle output from preprocessors 58 */ 59 AslCode 60 : DefinitionBlockList {$<n>$ = TrLinkOpChildren ( 61 TrCreateLeafOp (PARSEOP_ASL_CODE),1, $1);} 62 | error {YYABORT; $$ = NULL;} 63 ; 64 65 66 /* 67 * Note concerning support for "module-level code". 68 * 69 * ACPI 1.0 allowed Type1 and Type2 executable opcodes outside of control 70 * methods (the so-called module-level code.) This support was explicitly 71 * removed in ACPI 2.0, but this type of code continues to be created by 72 * BIOS vendors. In order to support the disassembly and recompilation of 73 * such code (and the porting of ASL code to iASL), iASL supports this 74 * code in violation of the current ACPI specification. 75 * 76 * The grammar change to support module-level code is to revert the 77 * {ObjectList} portion of the DefinitionBlockTerm in ACPI 2.0 to the 78 * original use of {TermList} instead (see below.) This allows the use 79 * of Type1 and Type2 opcodes at module level. 80 * 81 * 04/2016: The module-level code is now allowed in the following terms: 82 * DeviceTerm, PowerResTerm, ProcessorTerm, ScopeTerm, ThermalZoneTerm. 83 * The ObjectList term is obsolete and has been removed. 84 */ 85 DefinitionBlockTerm 86 : PARSEOP_DEFINITION_BLOCK 87 PARSEOP_OPEN_PAREN {$<n>$ = TrCreateLeafOp (PARSEOP_DEFINITION_BLOCK); COMMENT_CAPTURE_OFF;} 88 String ',' 89 String ',' 90 ByteConst ',' 91 String ',' 92 String ',' 93 DWordConst 94 PARSEOP_CLOSE_PAREN {TrSetOpIntegerWidth ($6,$8); 95 TrSetOpEndLineNumber ($<n>3); COMMENT_CAPTURE_ON;} 96 '{' TermList '}' {$$ = TrLinkOpChildren ($<n>3,7, 97 $4,$6,$8,$10,$12,$14,$18);} 98 ; 99 100 DefinitionBlockList 101 : DefinitionBlockTerm 102 | DefinitionBlockTerm 103 DefinitionBlockList {$$ = TrLinkPeerOps (2, $1,$2);} 104 ; 105 106 107 /******* Basic ASCII identifiers **************************************************/ 108 109 /* Allow IO, DMA, IRQ Resource macro and FOR macro names to also be used as identifiers */ 110 111 NameString 112 : NameSeg {} 113 | PARSEOP_NAMESTRING {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) $1);} 114 | PARSEOP_IO {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IO");} 115 | PARSEOP_DMA {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "DMA");} 116 | PARSEOP_IRQ {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IRQ");} 117 | PARSEOP_FOR {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "FOR");} 118 ; 119 /* 120 NameSeg 121 : PARSEOP_NAMESEG {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESEG, (ACPI_NATIVE_INT) 122 TrNormalizeNameSeg ($1));} 123 ; 124 */ 125 126 NameSeg 127 : PARSEOP_NAMESEG {$$ = TrCreateValuedLeafOp (PARSEOP_NAMESEG, 128 (ACPI_NATIVE_INT) AslCompilerlval.s);} 129 ; 130 131 132 /******* Fundamental argument/statement types ***********************************/ 133 134 Term 135 : Object {} 136 | Type1Opcode {} 137 | Type2Opcode {} 138 | Type2IntegerOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 139 | Type2StringOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 140 | Type2BufferOpcode {} 141 | Type2BufferOrStringOpcode {} 142 | error {$$ = AslDoError(); yyclearin;} 143 ; 144 145 SuperName 146 : SimpleName {} 147 | DebugTerm {} 148 | Type6Opcode {} 149 ; 150 151 Target 152 : {$$ = TrCreateNullTargetOp ();} /* Placeholder is a ZeroOp object */ 153 | ',' {$$ = TrCreateNullTargetOp ();} /* Placeholder is a ZeroOp object */ 154 | ',' SuperName {$$ = TrSetOpFlags ($2, OP_IS_TARGET);} 155 ; 156 157 RequiredTarget 158 : ',' SuperName {$$ = TrSetOpFlags ($2, OP_IS_TARGET);} 159 ; 160 161 TermArg 162 : SimpleName {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);} 163 | Type2Opcode {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);} 164 | DataObject {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);} 165 | PARSEOP_OPEN_PAREN 166 TermArg 167 PARSEOP_CLOSE_PAREN {$$ = TrSetOpFlags ($2, OP_IS_TERM_ARG);} 168 ; 169 170 /* 171 NOTE: Removed from TermArg due to reduce/reduce conflicts: 172 | Type2IntegerOpcode {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);} 173 | Type2StringOpcode {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);} 174 | Type2BufferOpcode {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);} 175 | Type2BufferOrStringOpcode {$$ = TrSetOpFlags ($1, OP_IS_TERM_ARG);} 176 177 */ 178 179 MethodInvocationTerm 180 : NameString 181 PARSEOP_OPEN_PAREN {TrSetOpIntegerValue (PARSEOP_METHODCALL, $1); COMMENT_CAPTURE_OFF;} 182 ArgList 183 PARSEOP_CLOSE_PAREN {$$ = TrLinkChildOp ($1,$4); COMMENT_CAPTURE_ON;} 184 ; 185 186 /* OptionalCount must appear before ByteList or an incorrect reduction will result */ 187 188 OptionalCount 189 : {$$ = TrCreateLeafOp (PARSEOP_ONES);} /* Placeholder is a OnesOp object */ 190 | ',' {$$ = TrCreateLeafOp (PARSEOP_ONES);} /* Placeholder is a OnesOp object */ 191 | ',' TermArg {$$ = $2;} 192 ; 193 194 /* 195 * Data count for buffers and packages (byte count for buffers, 196 * element count for packages). 197 */ 198 OptionalDataCount 199 200 /* Legacy ASL */ 201 : {$$ = NULL;} 202 | PARSEOP_OPEN_PAREN 203 TermArg 204 PARSEOP_CLOSE_PAREN {$$ = $2;} 205 | PARSEOP_OPEN_PAREN 206 PARSEOP_CLOSE_PAREN {$$ = NULL;} 207 208 /* C-style (ASL+) -- adds equals term */ 209 210 | PARSEOP_EXP_EQUALS {$$ = NULL;} 211 212 | PARSEOP_OPEN_PAREN 213 TermArg 214 PARSEOP_CLOSE_PAREN 215 PARSEOP_EXP_EQUALS {$$ = $2;} 216 217 | PARSEOP_OPEN_PAREN 218 PARSEOP_CLOSE_PAREN 219 String 220 PARSEOP_EXP_EQUALS {$$ = NULL;} 221 ; 222 223 224 /******* List Terms **************************************************/ 225 226 /* ACPI 3.0 -- allow semicolons between terms */ 227 228 TermList 229 : {$$ = NULL;} 230 | TermList Term {$$ = TrLinkPeerOp ( 231 TrSetOpFlags ($1, OP_RESULT_NOT_USED),$2);} 232 | TermList Term ';' {$$ = TrLinkPeerOp ( 233 TrSetOpFlags ($1, OP_RESULT_NOT_USED),$2);} 234 | TermList ';' Term {$$ = TrLinkPeerOp ( 235 TrSetOpFlags ($1, OP_RESULT_NOT_USED),$3);} 236 | TermList ';' Term ';' {$$ = TrLinkPeerOp ( 237 TrSetOpFlags ($1, OP_RESULT_NOT_USED),$3);} 238 ; 239 240 ArgList 241 : {$$ = NULL;} 242 | TermArg 243 | ArgList ',' /* Allows a trailing comma at list end */ 244 | ArgList ',' 245 TermArg {$$ = TrLinkPeerOp ($1,$3);} 246 ; 247 248 ByteList 249 : {$$ = NULL;} 250 | ByteConstExpr 251 | ByteList ',' /* Allows a trailing comma at list end */ 252 | ByteList ',' 253 ByteConstExpr {$$ = TrLinkPeerOp ($1,$3);} 254 ; 255 256 DWordList 257 : {$$ = NULL;} 258 | DWordConstExpr 259 | DWordList ',' /* Allows a trailing comma at list end */ 260 | DWordList ',' 261 DWordConstExpr {$$ = TrLinkPeerOp ($1,$3);} 262 ; 263 264 FieldUnitList 265 : {$$ = NULL;} 266 | FieldUnit 267 | FieldUnitList ',' /* Allows a trailing comma at list end */ 268 | FieldUnitList ',' 269 FieldUnit {$$ = TrLinkPeerOp ($1,$3);} 270 ; 271 272 FieldUnit 273 : FieldUnitEntry {} 274 | OffsetTerm {} 275 | AccessAsTerm {} 276 | ConnectionTerm {} 277 ; 278 279 FieldUnitEntry 280 : ',' AmlPackageLengthTerm {$$ = TrCreateOp (PARSEOP_RESERVED_BYTES,1,$2);} 281 | NameSeg ',' 282 AmlPackageLengthTerm {$$ = TrLinkChildOp ($1,$3);} 283 ; 284 285 Object 286 : CompilerDirective {} 287 | NamedObject {} 288 | NameSpaceModifier {} 289 /* | StructureTerm {} */ 290 ; 291 292 PackageList 293 : {$$ = NULL;} 294 | PackageElement 295 | PackageList ',' /* Allows a trailing comma at list end */ 296 | PackageList ',' 297 PackageElement {$$ = TrLinkPeerOp ($1,$3);} 298 ; 299 300 PackageElement 301 : DataObject {} 302 | NameString {} 303 ; 304 305 /* Rules for specifying the type of one method argument or return value */ 306 307 ParameterTypePackage 308 : {$$ = NULL;} 309 | ObjectTypeKeyword {$$ = $1;} 310 | ParameterTypePackage ',' 311 ObjectTypeKeyword {$$ = TrLinkPeerOps (2,$1,$3);} 312 ; 313 314 ParameterTypePackageList 315 : {$$ = NULL;} 316 | ObjectTypeKeyword {$$ = $1;} 317 | '{' ParameterTypePackage '}' {$$ = $2;} 318 ; 319 320 OptionalParameterTypePackage 321 : {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);} 322 | ',' ParameterTypePackageList {$$ = TrLinkOpChildren ( 323 TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);} 324 ; 325 326 /* Rules for specifying the types for method arguments */ 327 328 ParameterTypesPackage 329 : ParameterTypePackageList {$$ = $1;} 330 | ParameterTypesPackage ',' 331 ParameterTypePackageList {$$ = TrLinkPeerOps (2,$1,$3);} 332 ; 333 334 ParameterTypesPackageList 335 : {$$ = NULL;} 336 | ObjectTypeKeyword {$$ = $1;} 337 | '{' ParameterTypesPackage '}' {$$ = $2;} 338 ; 339 340 OptionalParameterTypesPackage 341 : {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);} 342 | ',' ParameterTypesPackageList {$$ = TrLinkOpChildren ( 343 TrCreateLeafOp (PARSEOP_DEFAULT_ARG),1,$2);} 344 ; 345 346 /* 347 * Case-Default list; allow only one Default term and unlimited Case terms 348 */ 349 CaseDefaultTermList 350 : {$$ = NULL;} 351 | CaseTerm {} 352 | DefaultTerm {} 353 | CaseDefaultTermList 354 CaseTerm {$$ = TrLinkPeerOp ($1,$2);} 355 | CaseDefaultTermList 356 DefaultTerm {$$ = TrLinkPeerOp ($1,$2);} 357 358 /* Original - attempts to force zero or one default term within the switch */ 359 360 /* 361 CaseDefaultTermList 362 : {$$ = NULL;} 363 | CaseTermList 364 DefaultTerm 365 CaseTermList {$$ = TrLinkPeerOp ($1,TrLinkPeerOp ($2, $3));} 366 | CaseTermList 367 CaseTerm {$$ = TrLinkPeerOp ($1,$2);} 368 ; 369 370 CaseTermList 371 : {$$ = NULL;} 372 | CaseTerm {} 373 | CaseTermList 374 CaseTerm {$$ = TrLinkPeerOp ($1,$2);} 375 ; 376 */ 377 378 379 /******************************************************************************* 380 * 381 * ASL Data and Constant Terms 382 * 383 ******************************************************************************/ 384 385 DataObject 386 : BufferData {} 387 | PackageData {} 388 | IntegerData {} 389 | StringData {} 390 ; 391 392 BufferData 393 : Type5Opcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 394 | Type2BufferOrStringOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 395 | Type2BufferOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 396 | BufferTerm {} 397 ; 398 399 PackageData 400 : PackageTerm {} 401 ; 402 403 IntegerData 404 : Type2IntegerOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 405 | Type3Opcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 406 | Integer {} 407 | ConstTerm {} 408 ; 409 410 StringData 411 : Type2StringOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 412 | String {} 413 ; 414 415 ByteConst 416 : Integer {$$ = TrSetOpIntegerValue (PARSEOP_BYTECONST, $1);} 417 ; 418 419 WordConst 420 : Integer {$$ = TrSetOpIntegerValue (PARSEOP_WORDCONST, $1);} 421 ; 422 423 DWordConst 424 : Integer {$$ = TrSetOpIntegerValue (PARSEOP_DWORDCONST, $1);} 425 ; 426 427 QWordConst 428 : Integer {$$ = TrSetOpIntegerValue (PARSEOP_QWORDCONST, $1);} 429 ; 430 431 /* 432 * The OP_COMPILE_TIME_CONST flag in the following constant expressions 433 * enables compile-time constant folding to reduce the Type3Opcodes/Type2IntegerOpcodes 434 * to simple integers. It is an error if these types of expressions cannot be 435 * reduced, since the AML grammar for ****ConstExpr requires a simple constant. 436 * Note: The required byte length of the constant is passed through to the 437 * constant folding code in the node AmlLength field. 438 */ 439 ByteConstExpr 440 : Type3Opcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST); 441 TrSetOpAmlLength ($1, 1);} 442 | Type2IntegerOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST); 443 TrSetOpAmlLength ($1, 1);} 444 | ConstExprTerm {$$ = TrSetOpIntegerValue (PARSEOP_BYTECONST, $1);} 445 | ByteConst {} 446 ; 447 448 WordConstExpr 449 : Type3Opcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST); 450 TrSetOpAmlLength ($1, 2);} 451 | Type2IntegerOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST); 452 TrSetOpAmlLength ($1, 2);} 453 | ConstExprTerm {$$ = TrSetOpIntegerValue (PARSEOP_WORDCONST, $1);} 454 | WordConst {} 455 ; 456 457 DWordConstExpr 458 : Type3Opcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST); 459 TrSetOpAmlLength ($1, 4);} 460 | Type2IntegerOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST); 461 TrSetOpAmlLength ($1, 4);} 462 | ConstExprTerm {$$ = TrSetOpIntegerValue (PARSEOP_DWORDCONST, $1);} 463 | DWordConst {} 464 ; 465 466 QWordConstExpr 467 : Type3Opcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST); 468 TrSetOpAmlLength ($1, 8);} 469 | Type2IntegerOpcode {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST); 470 TrSetOpAmlLength ($1, 8);} 471 | ConstExprTerm {$$ = TrSetOpIntegerValue (PARSEOP_QWORDCONST, $1);} 472 | QWordConst {} 473 ; 474 475 ConstTerm 476 : ConstExprTerm {} 477 | PARSEOP_REVISION {$$ = TrCreateLeafOp (PARSEOP_REVISION);} 478 ; 479 480 ConstExprTerm 481 : PARSEOP_ZERO {$$ = TrCreateValuedLeafOp (PARSEOP_ZERO, 0);} 482 | PARSEOP_ONE {$$ = TrCreateValuedLeafOp (PARSEOP_ONE, 1);} 483 | PARSEOP_ONES {$$ = TrCreateValuedLeafOp (PARSEOP_ONES, ACPI_UINT64_MAX);} 484 | PARSEOP___DATE__ {$$ = TrCreateConstantLeafOp (PARSEOP___DATE__);} 485 | PARSEOP___FILE__ {$$ = TrCreateConstantLeafOp (PARSEOP___FILE__);} 486 | PARSEOP___LINE__ {$$ = TrCreateConstantLeafOp (PARSEOP___LINE__);} 487 | PARSEOP___PATH__ {$$ = TrCreateConstantLeafOp (PARSEOP___PATH__);} 488 | PARSEOP___METHOD__ {$$ = TrCreateConstantLeafOp (PARSEOP___METHOD__);} 489 ; 490 491 Integer 492 : PARSEOP_INTEGER {$$ = TrCreateValuedLeafOp (PARSEOP_INTEGER, 493 AslCompilerlval.i);} 494 ; 495 496 String 497 : PARSEOP_STRING_LITERAL {$$ = TrCreateValuedLeafOp (PARSEOP_STRING_LITERAL, 498 (ACPI_NATIVE_INT) AslCompilerlval.s);} 499 ; 500 501 502 /******************************************************************************* 503 * 504 * ASL Opcode Terms 505 * 506 ******************************************************************************/ 507 508 CompilerDirective 509 : IncludeTerm {} 510 | IncludeEndTerm {} 511 | ExternalTerm {} 512 ; 513 514 NamedObject 515 : BankFieldTerm {} 516 | CreateBitFieldTerm {} 517 | CreateByteFieldTerm {} 518 | CreateDWordFieldTerm {} 519 | CreateFieldTerm {} 520 | CreateQWordFieldTerm {} 521 | CreateWordFieldTerm {} 522 | DataRegionTerm {} 523 | DeviceTerm {} 524 | EventTerm {} 525 | FieldTerm {} 526 | FunctionTerm {} 527 | IndexFieldTerm {} 528 | MethodTerm {} 529 | MutexTerm {} 530 | OpRegionTerm {} 531 | PowerResTerm {} 532 | ProcessorTerm {} 533 | ThermalZoneTerm {} 534 ; 535 536 NameSpaceModifier 537 : AliasTerm {} 538 | NameTerm {} 539 /* | NameTermAslPlus {} */ 540 | ScopeTerm {} 541 ; 542 543 SimpleName 544 : NameString {} 545 | LocalTerm {} 546 | ArgTerm {} 547 ; 548 549 /* For ObjectType(), SuperName except for MethodInvocationTerm */ 550 551 ObjectTypeSource 552 : SimpleName {} 553 | DebugTerm {} 554 | RefOfTerm {} 555 | DerefOfTerm {} 556 | IndexTerm {} 557 | IndexExpTerm {} 558 ; 559 560 /* For DeRefOf(), SuperName except for DerefOf and Debug */ 561 562 DerefOfSource 563 : SimpleName {} 564 | RefOfTerm {} 565 | DerefOfTerm {} 566 | IndexTerm {} 567 | IndexExpTerm {} 568 | StoreTerm {} 569 | EqualsTerm {} 570 | MethodInvocationTerm {} 571 ; 572 573 /* For RefOf(), SuperName except for RefOf and MethodInvocationTerm */ 574 575 RefOfSource 576 : SimpleName {} 577 | DebugTerm {} 578 | DerefOfTerm {} 579 | IndexTerm {} 580 | IndexExpTerm {} 581 ; 582 583 /* For CondRefOf(), SuperName except for RefOf and MethodInvocationTerm */ 584 585 CondRefOfSource 586 : SimpleName {} 587 | DebugTerm {} 588 | DerefOfTerm {} 589 | IndexTerm {} 590 | IndexExpTerm {} 591 ; 592 593 /* 594 * Opcode types, as defined in the ACPI specification 595 */ 596 Type1Opcode 597 : BreakTerm {} 598 | BreakPointTerm {} 599 | ContinueTerm {} 600 | FatalTerm {} 601 | ForTerm {} 602 | ElseIfTerm {} 603 | LoadTerm {} 604 | NoOpTerm {} 605 | NotifyTerm {} 606 | ReleaseTerm {} 607 | ResetTerm {} 608 | ReturnTerm {} 609 | SignalTerm {} 610 | SleepTerm {} 611 | StallTerm {} 612 | SwitchTerm {} 613 | UnloadTerm {} 614 | WhileTerm {} 615 ; 616 617 Type2Opcode 618 : AcquireTerm {} 619 | CondRefOfTerm {} 620 | CopyObjectTerm {} 621 | DerefOfTerm {} 622 | ObjectTypeTerm {} 623 | RefOfTerm {} 624 | SizeOfTerm {} 625 | StoreTerm {} 626 | EqualsTerm {} 627 | TimerTerm {} 628 | WaitTerm {} 629 | MethodInvocationTerm {} 630 ; 631 632 /* 633 * Type 3/4/5 opcodes 634 */ 635 Type2IntegerOpcode /* "Type3" opcodes */ 636 : Expression {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 637 | AddTerm {} 638 | AndTerm {} 639 | DecTerm {} 640 | DivideTerm {} 641 | FindSetLeftBitTerm {} 642 | FindSetRightBitTerm {} 643 | FromBCDTerm {} 644 | IncTerm {} 645 | IndexTerm {} 646 /* | StructureIndexTerm {} */ 647 /* | StructurePointerTerm {} */ 648 | LAndTerm {} 649 | LEqualTerm {} 650 | LGreaterTerm {} 651 | LGreaterEqualTerm {} 652 | LLessTerm {} 653 | LLessEqualTerm {} 654 | LNotTerm {} 655 | LNotEqualTerm {} 656 | LoadTableTerm {} 657 | LOrTerm {} 658 | MatchTerm {} 659 | ModTerm {} 660 | MultiplyTerm {} 661 | NAndTerm {} 662 | NOrTerm {} 663 | NotTerm {} 664 | OrTerm {} 665 | ShiftLeftTerm {} 666 | ShiftRightTerm {} 667 | SubtractTerm {} 668 | ToBCDTerm {} 669 | ToIntegerTerm {} 670 | XOrTerm {} 671 ; 672 673 Type2StringOpcode /* "Type4" Opcodes */ 674 : ToDecimalStringTerm {} 675 | ToHexStringTerm {} 676 | ToStringTerm {} 677 ; 678 679 Type2BufferOpcode /* "Type5" Opcodes */ 680 : ToBufferTerm {} 681 | ConcatResTerm {} 682 ; 683 684 Type2BufferOrStringOpcode 685 : ConcatTerm {$$ = TrSetOpFlags ($1, OP_COMPILE_TIME_CONST);} 686 | PrintfTerm {} 687 | FprintfTerm {} 688 | MidTerm {} 689 ; 690 691 /* 692 * A type 3 opcode evaluates to an Integer and cannot have a destination operand 693 */ 694 Type3Opcode 695 : EISAIDTerm {} 696 ; 697 698 /* Obsolete 699 Type4Opcode 700 : ConcatTerm {} 701 | ToDecimalStringTerm {} 702 | ToHexStringTerm {} 703 | MidTerm {} 704 | ToStringTerm {} 705 ; 706 */ 707 708 /* Type 5 opcodes are a subset of Type2 opcodes, and return a constant */ 709 710 Type5Opcode 711 : ResourceTemplateTerm {} 712 | UnicodeTerm {} 713 | ToPLDTerm {} 714 | ToUUIDTerm {} 715 ; 716 717 Type6Opcode 718 : RefOfTerm {} 719 | DerefOfTerm {} 720 | IndexTerm {} 721 | IndexExpTerm {} 722 /* | StructureIndexTerm {} */ 723 /* | StructurePointerTerm {} */ 724 | MethodInvocationTerm {} 725 ; 726 727 728 /******************************************************************************* 729 * 730 * ASL Helper Terms 731 * 732 ******************************************************************************/ 733 734 AmlPackageLengthTerm 735 : Integer {$$ = TrSetOpIntegerValue (PARSEOP_PACKAGE_LENGTH, 736 (ACPI_PARSE_OBJECT *) $1);} 737 ; 738 739 NameStringItem 740 : ',' NameString {$$ = $2;} 741 | ',' error {$$ = AslDoError (); yyclearin;} 742 ; 743 744 TermArgItem 745 : ',' TermArg {$$ = $2;} 746 | ',' error {$$ = AslDoError (); yyclearin;} 747 ; 748 749 OptionalReference 750 : {$$ = TrCreateLeafOp (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */ 751 | ',' {$$ = TrCreateLeafOp (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */ 752 | ',' TermArg {$$ = $2;} 753 ; 754 755 OptionalReturnArg 756 : {$$ = TrSetOpFlags (TrCreateLeafOp (PARSEOP_ZERO), 757 OP_IS_NULL_RETURN);} /* Placeholder is a ZeroOp object */ 758 | TermArg {$$ = $1;} 759 ; 760 761 OptionalSerializeRuleKeyword 762 : {$$ = NULL;} 763 | ',' {$$ = NULL;} 764 | ',' SerializeRuleKeyword {$$ = $2;} 765 ; 766 767 OptionalTermArg 768 : {$$ = TrCreateLeafOp (PARSEOP_DEFAULT_ARG);} 769 | TermArg {$$ = $1;} 770 ; 771 772 OptionalWordConst 773 : {$$ = NULL;} 774 | WordConst {$$ = $1;} 775 ; 776
Indexes created Mon Sep 29 21:09:56 GMT 2025