l4/pkg/acpica/lib-acpi/src/acpica/compiler/aslcompiler.h

   1
   2 /******************************************************************************
   3  *
   4  * Module Name: aslcompiler.h - common include file for iASL
   5  *
   6  *****************************************************************************/
   7
   8 /******************************************************************************
   9  *
  10  * 1. Copyright Notice
  11  *
  12  * Some or all of this work - Copyright (c) 1999 - 2009, Intel Corp.
  13  * All rights reserved.
  14  *
  15  * 2. License
  16  *
  17  * 2.1. This is your license from Intel Corp. under its intellectual property
  18  * rights.  You may have additional license terms from the party that provided
  19  * you this software, covering your right to use that party's intellectual
  20  * property rights.
  21  *
  22  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23  * copy of the source code appearing in this file ("Covered Code") an
  24  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26  * make derivatives, distribute, use and display any portion of the Covered
  27  * Code in any form, with the right to sublicense such rights; and
  28  *
  29  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30  * license (with the right to sublicense), under only those claims of Intel
  31  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32  * offer to sell, and import the Covered Code and derivative works thereof
  33  * solely to the minimum extent necessary to exercise the above copyright
  34  * license, and in no event shall the patent license extend to any additions
  35  * to or modifications of the Original Intel Code.  No other license or right
  36  * is granted directly or by implication, estoppel or otherwise;
  37  *
  38  * The above copyright and patent license is granted only if the following
  39  * conditions are met:
  40  *
  41  * 3. Conditions
  42  *
  43  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44  * Redistribution of source code of any substantial portion of the Covered
  45  * Code or modification with rights to further distribute source must include
  46  * the above Copyright Notice, the above License, this list of Conditions,
  47  * and the following Disclaimer and Export Compliance provision.  In addition,
  48  * Licensee must cause all Covered Code to which Licensee contributes to
  49  * contain a file documenting the changes Licensee made to create that Covered
  50  * Code and the date of any change.  Licensee must include in that file the
  51  * documentation of any changes made by any predecessor Licensee.  Licensee
  52  * must include a prominent statement that the modification is derived,
  53  * directly or indirectly, from Original Intel Code.
  54  *
  55  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56  * Redistribution of source code of any substantial portion of the Covered
  57  * Code or modification without rights to further distribute source must
  58  * include the following Disclaimer and Export Compliance provision in the
  59  * documentation and/or other materials provided with distribution.  In
  60  * addition, Licensee may not authorize further sublicense of source of any
  61  * portion of the Covered Code, and must include terms to the effect that the
  62  * license from Licensee to its licensee is limited to the intellectual
  63  * property embodied in the software Licensee provides to its licensee, and
  64  * not to intellectual property embodied in modifications its licensee may
  65  * make.
  66  *
  67  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68  * substantial portion of the Covered Code or modification must reproduce the
  69  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70  * provision in the documentation and/or other materials provided with the
  71  * distribution.
  72  *
  73  * 3.4. Intel retains all right, title, and interest in and to the Original
  74  * Intel Code.
  75  *
  76  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78  * other dealings in products derived from or relating to the Covered Code
  79  * without prior written authorization from Intel.
  80  *
  81  * 4. Disclaimer and Export Compliance
  82  *
  83  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89  * PARTICULAR PURPOSE.
  90  *
  91  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98  * LIMITED REMEDY.
  99  *
 100  * 4.3. Licensee shall not export, either directly or indirectly, any of this
 101  * software or system incorporating such software without first obtaining any
 102  * required license or other approval from the U. S. Department of Commerce or
 103  * any other agency or department of the United States Government.  In the
 104  * event Licensee exports any such software from the United States or
 105  * re-exports any such software from a foreign destination, Licensee shall
 106  * ensure that the distribution and export/re-export of the software is in
 107  * compliance with all laws, regulations, orders, or other restrictions of the
 108  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
 109  * any of its subsidiaries will export/re-export any technical data, process,
 110  * software, or service, directly or indirectly, to any country for which the
 111  * United States government or any agency thereof requires an export license,
 112  * other governmental approval, or letter of assurance, without first obtaining
 113  * such license, approval or letter.
 114  *
 115  *****************************************************************************/
 116
 117
 118 #ifndef __ASLCOMPILER_H
 119 #define __ASLCOMPILER_H
 120
 121
 122 /* Microsoft-specific */
 123
 124 #if (defined WIN32 || defined WIN64)
 125
 126 /* warn : used #pragma pack */
 127 #pragma warning(disable:4103)
 128
 129 /* warn : named type definition in parentheses */
 130 #pragma warning(disable:4115)
 131 #endif
 132
 133 #include <stdio.h>
 134 #include <stdlib.h>
 135 #include <stdarg.h>
 136 #include <string.h>
 137 #include <errno.h>
 138 #include <ctype.h>
 139
 140
 141 #include "acpi.h"
 142 #include "accommon.h"
 143 #include "amlresrc.h"
 144 #include "acdebug.h"
 145
 146 /* Compiler headers */
 147
 148 #include "asldefine.h"
 149 #include "asltypes.h"
 150 #include "aslglobal.h"
 151
 152
 153 /*******************************************************************************
 154  *
 155  * Compiler prototypes
 156  *
 157  ******************************************************************************/
 158
 159 /*
 160  * parser - generated from flex/bison, lex/yacc, etc.
 161  */
 162 int
 163 AslCompilerparse(
 164     void);
 165
 166 ACPI_PARSE_OBJECT *
 167 AslDoError (
 168     void);
 169
 170 int
 171 AslCompilerlex(
 172     void);
 173
 174 void
 175 ResetCurrentLineBuffer (
 176     void);
 177
 178 void
 179 InsertLineBuffer (
 180     int                     SourceChar);
 181
 182 int
 183 AslPopInputFileStack (
 184     void);
 185
 186 void
 187 AslPushInputFileStack (
 188     FILE                    *InputFile,
 189     char                    *Filename);
 190
 191 /*
 192  * aslstartup - called from main
 193  */
 194 ACPI_STATUS
 195 AslDoOnePathname (
 196     char                    *Pathname);
 197
 198 ACPI_STATUS
 199 AslDoOneFile (
 200     char                    *Filename);
 201
 202 /*
 203  * aslcompile - compile mainline
 204  */
 205 void
 206 AslCompilerSignon (
 207     UINT32                  FileId);
 208
 209 void
 210 AslCompilerFileHeader (
 211     UINT32                  FileId);
 212
 213 int
 214 CmDoCompile (
 215     void);
 216
 217 void
 218 CmDoOutputFiles (
 219     void);
 220
 221 void
 222 CmCleanupAndExit (
 223     void);
 224
 225
 226 /*
 227  * aslanalyze - semantic analysis
 228  */
 229 ACPI_STATUS
 230 AnOtherSemanticAnalysisWalkBegin (
 231     ACPI_PARSE_OBJECT       *Op,
 232     UINT32                  Level,
 233     void                    *Context);
 234
 235 ACPI_STATUS
 236 AnOtherSemanticAnalysisWalkEnd (
 237     ACPI_PARSE_OBJECT       *Op,
 238     UINT32                  Level,
 239     void                    *Context);
 240
 241 ACPI_STATUS
 242 AnOperandTypecheckWalkBegin (
 243     ACPI_PARSE_OBJECT       *Op,
 244     UINT32                  Level,
 245     void                    *Context);
 246
 247 ACPI_STATUS
 248 AnOperandTypecheckWalkEnd (
 249     ACPI_PARSE_OBJECT       *Op,
 250     UINT32                  Level,
 251     void                    *Context);
 252
 253 ACPI_STATUS
 254 AnMethodAnalysisWalkBegin (
 255     ACPI_PARSE_OBJECT       *Op,
 256     UINT32                  Level,
 257     void                    *Context);
 258
 259 ACPI_STATUS
 260 AnMethodAnalysisWalkEnd (
 261     ACPI_PARSE_OBJECT       *Op,
 262     UINT32                  Level,
 263     void                    *Context);
 264
 265 ACPI_STATUS
 266 AnMethodTypingWalkBegin (
 267     ACPI_PARSE_OBJECT       *Op,
 268     UINT32                  Level,
 269     void                    *Context);
 270
 271 ACPI_STATUS
 272 AnMethodTypingWalkEnd (
 273     ACPI_PARSE_OBJECT       *Op,
 274     UINT32                  Level,
 275     void                    *Context);
 276
 277
 278 /*
 279  * aslerror - error handling/reporting
 280  */
 281 void
 282 AslError (
 283     UINT8                   Level,
 284     UINT8                   MessageId,
 285     ACPI_PARSE_OBJECT       *Op,
 286     char                    *ExtraMessage);
 287
 288 void
 289 AslCoreSubsystemError (
 290     ACPI_PARSE_OBJECT       *Op,
 291     ACPI_STATUS             Status,
 292     char                    *ExtraMessage,
 293     BOOLEAN                 Abort);
 294
 295 int
 296 AslCompilererror(
 297     char                    *s);
 298
 299 void
 300 AslCommonError (
 301     UINT8                   Level,
 302     UINT8                   MessageId,
 303     UINT32                  CurrentLineNumber,
 304     UINT32                  LogicalLineNumber,
 305     UINT32                  LogicalByteOffset,
 306     UINT32                  Column,
 307     char                    *Filename,
 308     char                    *ExtraMessage);
 309
 310 void
 311 AePrintException (
 312     UINT32                  FileId,
 313     ASL_ERROR_MSG           *Enode,
 314     char                    *Header);
 315
 316 void
 317 AePrintErrorLog (
 318     UINT32                  FileId);
 319
 320 void
 321 AeClearErrorLog (
 322     void);
 323
 324 ACPI_PHYSICAL_ADDRESS
 325 AeLocalGetRootPointer (
 326     void);
 327
 328
 329 /*
 330  * asllisting - generate all "listing" type files
 331  */
 332 void
 333 LsDoListings (
 334     void);
 335
 336 void
 337 LsWriteNodeToAsmListing (
 338     ACPI_PARSE_OBJECT       *Op);
 339
 340 void
 341 LsWriteNode (
 342     ACPI_PARSE_OBJECT       *Op,
 343     UINT32                  FileId);
 344
 345 void
 346 LsDoHexOutput (
 347     void);
 348
 349 void
 350 LsDumpParseTree (
 351     void);
 352
 353 /*
 354  * aslfold - constant folding
 355  */
 356 ACPI_STATUS
 357 OpcAmlConstantWalk (
 358     ACPI_PARSE_OBJECT       *Op,
 359     UINT32                  Level,
 360     void                    *Context);
 361
 362
 363 /*
 364  * aslopcodes - generate AML opcodes
 365  */
 366 ACPI_STATUS
 367 OpcAmlOpcodeWalk (
 368     ACPI_PARSE_OBJECT       *Op,
 369     UINT32                  Level,
 370     void                    *Context);
 371
 372 ACPI_STATUS
 373 OpcAmlOpcodeUpdateWalk (
 374     ACPI_PARSE_OBJECT       *Op,
 375     UINT32                  Level,
 376     void                    *Context);
 377
 378 void
 379 OpcGenerateAmlOpcode (
 380     ACPI_PARSE_OBJECT       *Op);
 381
 382 UINT32
 383 OpcSetOptimalIntegerSize (
 384     ACPI_PARSE_OBJECT       *Op);
 385
 386 void
 387 OpcGetIntegerWidth (
 388     ACPI_PARSE_OBJECT       *Op);
 389
 390
 391 /*
 392  * asloperands - generate AML operands for the AML opcodes
 393  */
 394 ACPI_PARSE_OBJECT  *
 395 UtGetArg (
 396     ACPI_PARSE_OBJECT       *Op,
 397     UINT32                  Argn);
 398
 399 void
 400 OpnGenerateAmlOperands (
 401     ACPI_PARSE_OBJECT       *Op);
 402
 403 void
 404 OpnDoPackage (
 405     ACPI_PARSE_OBJECT       *Op);
 406
 407
 408 /*
 409  * aslopt - optmization
 410  */
 411 void
 412 OptOptimizeNamePath (
 413     ACPI_PARSE_OBJECT       *Op,
 414     UINT32                  Flags,
 415     ACPI_WALK_STATE         *WalkState,
 416     char                    *AmlNameString,
 417     ACPI_NAMESPACE_NODE     *TargetNode);
 418
 419
 420 /*
 421  * aslcodegen - code generation
 422  */
 423 void
 424 CgGenerateAmlOutput (
 425     void);
 426
 427
 428 /*
 429  * asllength - calculate/adjust AML package lengths
 430  */
 431 ACPI_STATUS
 432 LnPackageLengthWalk (
 433     ACPI_PARSE_OBJECT       *Op,
 434     UINT32                  Level,
 435     void                    *Context);
 436
 437 ACPI_STATUS
 438 LnInitLengthsWalk (
 439     ACPI_PARSE_OBJECT       *Op,
 440     UINT32                  Level,
 441     void                    *Context);
 442
 443 void
 444 CgGenerateAmlLengths (
 445     ACPI_PARSE_OBJECT       *Op);
 446
 447
 448 /*
 449  * aslmap - opcode mappings and reserved method names
 450  */
 451 ACPI_OBJECT_TYPE
 452 AslMapNamedOpcodeToDataType (
 453     UINT16                  Opcode);
 454
 455 void
 456 MpDisplayReservedNames (
 457     void);
 458
 459
 460 /*
 461  * asltransform - parse tree transformations
 462  */
 463 ACPI_STATUS
 464 TrAmlTransformWalk (
 465     ACPI_PARSE_OBJECT       *Op,
 466     UINT32                  Level,
 467     void                    *Context);
 468
 469
 470 /*
 471  * asltree - parse tree support
 472  */
 473 ACPI_STATUS
 474 TrWalkParseTree (
 475     ACPI_PARSE_OBJECT       *Op,
 476     UINT32                  Visitation,
 477     ASL_WALK_CALLBACK       DescendingCallback,
 478     ASL_WALK_CALLBACK       AscendingCallback,
 479     void                    *Context);
 480
 481 /* Values for "Visitation" parameter above */
 482
 483 #define ASL_WALK_VISIT_DOWNWARD     0x01
 484 #define ASL_WALK_VISIT_UPWARD       0x02
 485 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 486
 487
 488 ACPI_PARSE_OBJECT *
 489 TrAllocateNode (
 490     UINT32                  ParseOpcode);
 491
 492 void
 493 TrReleaseNode (
 494     ACPI_PARSE_OBJECT       *Op);
 495
 496 ACPI_PARSE_OBJECT *
 497 TrUpdateNode (
 498     UINT32                  ParseOpcode,
 499     ACPI_PARSE_OBJECT       *Op);
 500
 501 ACPI_PARSE_OBJECT *
 502 TrCreateNode (
 503     UINT32                  ParseOpcode,
 504     UINT32                  NumChildren,
 505     ...);
 506
 507 ACPI_PARSE_OBJECT *
 508 TrCreateLeafNode (
 509     UINT32                  ParseOpcode);
 510
 511 ACPI_PARSE_OBJECT *
 512 TrCreateValuedLeafNode (
 513     UINT32                  ParseOpcode,
 514     ACPI_INTEGER            Value);
 515
 516 ACPI_PARSE_OBJECT *
 517 TrLinkChildren (
 518     ACPI_PARSE_OBJECT       *Op,
 519     UINT32                  NumChildren,
 520     ...);
 521
 522 void
 523 TrSetEndLineNumber (
 524     ACPI_PARSE_OBJECT       *Op);
 525
 526 void
 527 TrWalkTree (
 528     void);
 529
 530 ACPI_PARSE_OBJECT *
 531 TrLinkPeerNode (
 532     ACPI_PARSE_OBJECT       *Op1,
 533     ACPI_PARSE_OBJECT       *Op2);
 534
 535 ACPI_PARSE_OBJECT *
 536 TrLinkChildNode (
 537     ACPI_PARSE_OBJECT       *Op1,
 538     ACPI_PARSE_OBJECT       *Op2);
 539
 540 ACPI_PARSE_OBJECT *
 541 TrSetNodeFlags (
 542     ACPI_PARSE_OBJECT       *Op,
 543     UINT32                  Flags);
 544
 545 ACPI_PARSE_OBJECT *
 546 TrLinkPeerNodes (
 547     UINT32                  NumPeers,
 548     ...);
 549
 550
 551 /*
 552  * aslfiles - File I/O support
 553  */
 554 void
 555 AslAbort (
 556     void);
 557
 558 void
 559 FlAddIncludeDirectory (
 560     char                    *Dir);
 561
 562 void
 563 FlOpenIncludeFile (
 564     ACPI_PARSE_OBJECT       *Op);
 565
 566 void
 567 FlFileError (
 568     UINT32                  FileId,
 569     UINT8                   ErrorId);
 570
 571 ACPI_STATUS
 572 FlReadFile (
 573     UINT32                  FileId,
 574     void                    *Buffer,
 575     UINT32                  Length);
 576
 577 void
 578 FlWriteFile (
 579     UINT32                  FileId,
 580     void                    *Buffer,
 581     UINT32                  Length);
 582
 583 void
 584 FlSeekFile (
 585     UINT32                  FileId,
 586     long                    Offset);
 587
 588 void
 589 FlCloseFile (
 590     UINT32                  FileId);
 591
 592 void
 593 FlPrintFile (
 594     UINT32                  FileId,
 595     char                    *Format,
 596     ...);
 597
 598 void
 599 FlSetLineNumber (
 600     ACPI_PARSE_OBJECT       *Op);
 601
 602 ACPI_STATUS
 603 FlOpenInputFile (
 604     char                    *InputFilename);
 605
 606 ACPI_STATUS
 607 FlOpenAmlOutputFile (
 608     char                    *InputFilename);
 609
 610 ACPI_STATUS
 611 FlOpenMiscOutputFiles (
 612     char                    *InputFilename);
 613
 614
 615 /*
 616  * asload - load namespace in prep for cross reference
 617  */
 618 ACPI_STATUS
 619 LdLoadNamespace (
 620     ACPI_PARSE_OBJECT       *RootOp);
 621
 622
 623 /*
 624  * asllookup - namespace cross reference
 625  */
 626 ACPI_STATUS
 627 LkCrossReferenceNamespace (
 628     void);
 629
 630 void
 631 LkFindUnreferencedObjects (
 632     void);
 633
 634 ACPI_STATUS
 635 LsDisplayNamespace (
 636     void);
 637
 638
 639 /*
 640  * aslutils - common compiler utilites
 641  */
 642 void
 643 DbgPrint (
 644     UINT32                  Type,
 645     char                    *Format,
 646     ...);
 647
 648 /* Type values for above */
 649
 650 #define ASL_DEBUG_OUTPUT    0
 651 #define ASL_PARSE_OUTPUT    1
 652 #define ASL_TREE_OUTPUT     2
 653
 654 void
 655 UtDisplayConstantOpcodes (
 656     void);
 657
 658 UINT8
 659 UtBeginEvent (
 660     char                    *Name);
 661
 662 void
 663 UtEndEvent (
 664     UINT8                   Event);
 665
 666 void *
 667 UtLocalCalloc (
 668     UINT32                  Size);
 669
 670 void
 671 UtPrintFormattedName (
 672     UINT16                  ParseOpcode,
 673     UINT32                  Level);
 674
 675 void
 676 UtDisplaySummary (
 677     UINT32                  FileId);
 678
 679 UINT8
 680 UtHexCharToValue (
 681     int                     HexChar);
 682
 683 void
 684 UtConvertByteToHex (
 685     UINT8                   RawByte,
 686     UINT8                   *Buffer);
 687
 688 void
 689 UtConvertByteToAsmHex (
 690     UINT8                   RawByte,
 691     UINT8                   *Buffer);
 692
 693 char *
 694 UtGetOpName (
 695     UINT32                  ParseOpcode);
 696
 697 void
 698 UtSetParseOpName (
 699     ACPI_PARSE_OBJECT       *Op);
 700
 701 char *
 702 UtGetStringBuffer (
 703     UINT32                  Length);
 704
 705 ACPI_STATUS
 706 UtInternalizeName (
 707     char                    *ExternalName,
 708     char                    **ConvertedName);
 709
 710 void
 711 UtAttachNamepathToOwner (
 712     ACPI_PARSE_OBJECT       *Op,
 713     ACPI_PARSE_OBJECT       *NameNode);
 714
 715 ACPI_PARSE_OBJECT *
 716 UtCheckIntegerRange (
 717     ACPI_PARSE_OBJECT       *Op,
 718     UINT32                  LowValue,
 719     UINT32                  HighValue);
 720
 721 ACPI_INTEGER
 722 UtDoConstant (
 723     char                    *String);
 724
 725
 726 /*
 727  * aslresource - Resource template generation utilities
 728  */
 729 ASL_RESOURCE_NODE *
 730 RsAllocateResourceNode (
 731     UINT32                  Size);
 732
 733 void
 734 RsCreateBitField (
 735     ACPI_PARSE_OBJECT       *Op,
 736     char                    *Name,
 737     UINT32                  ByteOffset,
 738     UINT32                  BitOffset);
 739
 740 void
 741 RsCreateByteField (
 742     ACPI_PARSE_OBJECT       *Op,
 743     char                    *Name,
 744     UINT32                  ByteOffset);
 745
 746 void
 747 RsSetFlagBits (
 748     UINT8                   *Flags,
 749     ACPI_PARSE_OBJECT       *Op,
 750     UINT8                   Position,
 751     UINT8                   DefaultBit);
 752
 753 ACPI_PARSE_OBJECT *
 754 RsCompleteNodeAndGetNext (
 755     ACPI_PARSE_OBJECT       *Op);
 756
 757 void
 758 RsCheckListForDuplicates (
 759     ACPI_PARSE_OBJECT       *Op);
 760
 761 ASL_RESOURCE_NODE *
 762 RsDoOneResourceDescriptor (
 763     ACPI_PARSE_OBJECT       *DescriptorTypeOp,
 764     UINT32                  CurrentByteOffset,
 765     UINT8                   *State);
 766
 767 /* Values for State above */
 768
 769 #define ACPI_RSTATE_NORMAL              0
 770 #define ACPI_RSTATE_START_DEPENDENT     1
 771 #define ACPI_RSTATE_DEPENDENT_LIST      2
 772
 773 UINT32
 774 RsLinkDescriptorChain (
 775     ASL_RESOURCE_NODE       **PreviousRnode,
 776     ASL_RESOURCE_NODE       *Rnode);
 777
 778 void
 779 RsDoResourceTemplate (
 780     ACPI_PARSE_OBJECT       *Op);
 781
 782
 783 /*
 784  * aslrestype1 - generate Small descriptors
 785  */
 786 ASL_RESOURCE_NODE *
 787 RsDoEndTagDescriptor (
 788     ACPI_PARSE_OBJECT       *Op,
 789     UINT32                  CurrentByteOffset);
 790
 791 ASL_RESOURCE_NODE *
 792 RsDoDmaDescriptor (
 793     ACPI_PARSE_OBJECT       *Op,
 794     UINT32                  CurrentByteOffset);
 795
 796 ASL_RESOURCE_NODE *
 797 RsDoEndDependentDescriptor (
 798     ACPI_PARSE_OBJECT       *Op,
 799     UINT32                  CurrentByteOffset);
 800
 801 ASL_RESOURCE_NODE *
 802 RsDoFixedIoDescriptor (
 803     ACPI_PARSE_OBJECT       *Op,
 804     UINT32                  CurrentByteOffset);
 805
 806 ASL_RESOURCE_NODE *
 807 RsDoIoDescriptor (
 808     ACPI_PARSE_OBJECT       *Op,
 809     UINT32                  CurrentByteOffset);
 810
 811 ASL_RESOURCE_NODE *
 812 RsDoIrqDescriptor (
 813     ACPI_PARSE_OBJECT       *Op,
 814     UINT32                  CurrentByteOffset);
 815
 816 ASL_RESOURCE_NODE *
 817 RsDoIrqNoFlagsDescriptor (
 818     ACPI_PARSE_OBJECT       *Op,
 819     UINT32                  CurrentByteOffset);
 820
 821 ASL_RESOURCE_NODE *
 822 RsDoMemory24Descriptor (
 823     ACPI_PARSE_OBJECT       *Op,
 824     UINT32                  CurrentByteOffset);
 825
 826 ASL_RESOURCE_NODE *
 827 RsDoMemory32Descriptor (
 828     ACPI_PARSE_OBJECT       *Op,
 829     UINT32                  CurrentByteOffset);
 830
 831 ASL_RESOURCE_NODE *
 832 RsDoMemory32FixedDescriptor (
 833     ACPI_PARSE_OBJECT       *Op,
 834     UINT32                  CurrentByteOffset);
 835
 836 ASL_RESOURCE_NODE *
 837 RsDoStartDependentDescriptor (
 838     ACPI_PARSE_OBJECT       *Op,
 839     UINT32                  CurrentByteOffset);
 840
 841 ASL_RESOURCE_NODE *
 842 RsDoStartDependentNoPriDescriptor (
 843     ACPI_PARSE_OBJECT       *Op,
 844     UINT32                  CurrentByteOffset);
 845
 846 ASL_RESOURCE_NODE *
 847 RsDoVendorSmallDescriptor (
 848     ACPI_PARSE_OBJECT       *Op,
 849     UINT32                  CurrentByteOffset);
 850
 851
 852 /*
 853  * aslrestype2 - generate Large descriptors
 854  */
 855 ASL_RESOURCE_NODE *
 856 RsDoInterruptDescriptor (
 857     ACPI_PARSE_OBJECT       *Op,
 858     UINT32                  CurrentByteOffset);
 859
 860 ASL_RESOURCE_NODE *
 861 RsDoDwordIoDescriptor (
 862     ACPI_PARSE_OBJECT       *Op,
 863     UINT32                  CurrentByteOffset);
 864
 865 ASL_RESOURCE_NODE *
 866 RsDoDwordMemoryDescriptor (
 867     ACPI_PARSE_OBJECT       *Op,
 868     UINT32                  CurrentByteOffset);
 869
 870 ASL_RESOURCE_NODE *
 871 RsDoDwordSpaceDescriptor (
 872     ACPI_PARSE_OBJECT       *Op,
 873     UINT32                  CurrentByteOffset);
 874
 875 ASL_RESOURCE_NODE *
 876 RsDoExtendedIoDescriptor (
 877     ACPI_PARSE_OBJECT       *Op,
 878     UINT32                  CurrentByteOffset);
 879
 880 ASL_RESOURCE_NODE *
 881 RsDoExtendedMemoryDescriptor (
 882     ACPI_PARSE_OBJECT       *Op,
 883     UINT32                  CurrentByteOffset);
 884
 885 ASL_RESOURCE_NODE *
 886 RsDoExtendedSpaceDescriptor (
 887     ACPI_PARSE_OBJECT       *Op,
 888     UINT32                  CurrentByteOffset);
 889
 890 ASL_RESOURCE_NODE *
 891 RsDoQwordIoDescriptor (
 892     ACPI_PARSE_OBJECT       *Op,
 893     UINT32                  CurrentByteOffset);
 894
 895 ASL_RESOURCE_NODE *
 896 RsDoQwordMemoryDescriptor (
 897     ACPI_PARSE_OBJECT       *Op,
 898     UINT32                  CurrentByteOffset);
 899
 900 ASL_RESOURCE_NODE *
 901 RsDoQwordSpaceDescriptor (
 902     ACPI_PARSE_OBJECT       *Op,
 903     UINT32                  CurrentByteOffset);
 904
 905 ASL_RESOURCE_NODE *
 906 RsDoWordIoDescriptor (
 907     ACPI_PARSE_OBJECT       *Op,
 908     UINT32                  CurrentByteOffset);
 909
 910 ASL_RESOURCE_NODE *
 911 RsDoWordSpaceDescriptor (
 912     ACPI_PARSE_OBJECT       *Op,
 913     UINT32                  CurrentByteOffset);
 914
 915 ASL_RESOURCE_NODE *
 916 RsDoWordBusNumberDescriptor (
 917     ACPI_PARSE_OBJECT       *Op,
 918     UINT32                  CurrentByteOffset);
 919
 920 ASL_RESOURCE_NODE *
 921 RsDoVendorLargeDescriptor (
 922     ACPI_PARSE_OBJECT       *Op,
 923     UINT32                  CurrentByteOffset);
 924
 925 ASL_RESOURCE_NODE *
 926 RsDoGeneralRegisterDescriptor (
 927     ACPI_PARSE_OBJECT       *Op,
 928     UINT32                  CurrentByteOffset);
 929
 930 #endif /*  __ASLCOMPILER_H */
 931