sys/external/intel-public/acpica/dist/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 FlOpenIncludeFile (
 560     ACPI_PARSE_OBJECT       *Op);
 561
 562 void
 563 FlFileError (
 564     UINT32                  FileId,
 565     UINT8                   ErrorId);
 566
 567 ACPI_STATUS
 568 FlReadFile (
 569     UINT32                  FileId,
 570     void                    *Buffer,
 571     UINT32                  Length);
 572
 573 void
 574 FlWriteFile (
 575     UINT32                  FileId,
 576     void                    *Buffer,
 577     UINT32                  Length);
 578
 579 void
 580 FlSeekFile (
 581     UINT32                  FileId,
 582     long                    Offset);
 583
 584 void
 585 FlCloseFile (
 586     UINT32                  FileId);
 587
 588 void
 589 FlPrintFile (
 590     UINT32                  FileId,
 591     char                    *Format,
 592     ...);
 593
 594 void
 595 FlSetLineNumber (
 596     ACPI_PARSE_OBJECT       *Op);
 597
 598 ACPI_STATUS
 599 FlOpenInputFile (
 600     char                    *InputFilename);
 601
 602 ACPI_STATUS
 603 FlOpenAmlOutputFile (
 604     char                    *InputFilename);
 605
 606 ACPI_STATUS
 607 FlOpenMiscOutputFiles (
 608     char                    *InputFilename);
 609
 610
 611 /*
 612  * asload - load namespace in prep for cross reference
 613  */
 614 ACPI_STATUS
 615 LdLoadNamespace (
 616     ACPI_PARSE_OBJECT       *RootOp);
 617
 618
 619 /*
 620  * asllookup - namespace cross reference
 621  */
 622 ACPI_STATUS
 623 LkCrossReferenceNamespace (
 624     void);
 625
 626 void
 627 LkFindUnreferencedObjects (
 628     void);
 629
 630 ACPI_STATUS
 631 LsDisplayNamespace (
 632     void);
 633
 634
 635 /*
 636  * aslutils - common compiler utilites
 637  */
 638 void
 639 DbgPrint (
 640     UINT32                  Type,
 641     char                    *Format,
 642     ...);
 643
 644 /* Type values for above */
 645
 646 #define ASL_DEBUG_OUTPUT    0
 647 #define ASL_PARSE_OUTPUT    1
 648 #define ASL_TREE_OUTPUT     2
 649
 650 void
 651 UtDisplayConstantOpcodes (
 652     void);
 653
 654 UINT8
 655 UtBeginEvent (
 656     char                    *Name);
 657
 658 void
 659 UtEndEvent (
 660     UINT8                   Event);
 661
 662 void *
 663 UtLocalCalloc (
 664     UINT32                  Size);
 665
 666 void
 667 UtPrintFormattedName (
 668     UINT16                  ParseOpcode,
 669     UINT32                  Level);
 670
 671 void
 672 UtDisplaySummary (
 673     UINT32                  FileId);
 674
 675 UINT8
 676 UtHexCharToValue (
 677     int                     HexChar);
 678
 679 void
 680 UtConvertByteToHex (
 681     UINT8                   RawByte,
 682     UINT8                   *Buffer);
 683
 684 void
 685 UtConvertByteToAsmHex (
 686     UINT8                   RawByte,
 687     UINT8                   *Buffer);
 688
 689 char *
 690 UtGetOpName (
 691     UINT32                  ParseOpcode);
 692
 693 void
 694 UtSetParseOpName (
 695     ACPI_PARSE_OBJECT       *Op);
 696
 697 char *
 698 UtGetStringBuffer (
 699     UINT32                  Length);
 700
 701 ACPI_STATUS
 702 UtInternalizeName (
 703     char                    *ExternalName,
 704     char                    **ConvertedName);
 705
 706 void
 707 UtAttachNamepathToOwner (
 708     ACPI_PARSE_OBJECT       *Op,
 709     ACPI_PARSE_OBJECT       *NameNode);
 710
 711 ACPI_PARSE_OBJECT *
 712 UtCheckIntegerRange (
 713     ACPI_PARSE_OBJECT       *Op,
 714     UINT32                  LowValue,
 715     UINT32                  HighValue);
 716
 717 ACPI_INTEGER
 718 UtDoConstant (
 719     char                    *String);
 720
 721
 722 /*
 723  * aslresource - Resource template generation utilities
 724  */
 725 ASL_RESOURCE_NODE *
 726 RsAllocateResourceNode (
 727     UINT32                  Size);
 728
 729 void
 730 RsCreateBitField (
 731     ACPI_PARSE_OBJECT       *Op,
 732     char                    *Name,
 733     UINT32                  ByteOffset,
 734     UINT32                  BitOffset);
 735
 736 void
 737 RsCreateByteField (
 738     ACPI_PARSE_OBJECT       *Op,
 739     char                    *Name,
 740     UINT32                  ByteOffset);
 741
 742 void
 743 RsSetFlagBits (
 744     UINT8                   *Flags,
 745     ACPI_PARSE_OBJECT       *Op,
 746     UINT8                   Position,
 747     UINT8                   DefaultBit);
 748
 749 ACPI_PARSE_OBJECT *
 750 RsCompleteNodeAndGetNext (
 751     ACPI_PARSE_OBJECT       *Op);
 752
 753 void
 754 RsCheckListForDuplicates (
 755     ACPI_PARSE_OBJECT       *Op);
 756
 757 ASL_RESOURCE_NODE *
 758 RsDoOneResourceDescriptor (
 759     ACPI_PARSE_OBJECT       *DescriptorTypeOp,
 760     UINT32                  CurrentByteOffset,
 761     UINT8                   *State);
 762
 763 /* Values for State above */
 764
 765 #define ACPI_RSTATE_NORMAL              0
 766 #define ACPI_RSTATE_START_DEPENDENT     1
 767 #define ACPI_RSTATE_DEPENDENT_LIST      2
 768
 769 UINT32
 770 RsLinkDescriptorChain (
 771     ASL_RESOURCE_NODE       **PreviousRnode,
 772     ASL_RESOURCE_NODE       *Rnode);
 773
 774 void
 775 RsDoResourceTemplate (
 776     ACPI_PARSE_OBJECT       *Op);
 777
 778
 779 /*
 780  * aslrestype1 - generate Small descriptors
 781  */
 782 ASL_RESOURCE_NODE *
 783 RsDoEndTagDescriptor (
 784     ACPI_PARSE_OBJECT       *Op,
 785     UINT32                  CurrentByteOffset);
 786
 787 ASL_RESOURCE_NODE *
 788 RsDoDmaDescriptor (
 789     ACPI_PARSE_OBJECT       *Op,
 790     UINT32                  CurrentByteOffset);
 791
 792 ASL_RESOURCE_NODE *
 793 RsDoEndDependentDescriptor (
 794     ACPI_PARSE_OBJECT       *Op,
 795     UINT32                  CurrentByteOffset);
 796
 797 ASL_RESOURCE_NODE *
 798 RsDoFixedIoDescriptor (
 799     ACPI_PARSE_OBJECT       *Op,
 800     UINT32                  CurrentByteOffset);
 801
 802 ASL_RESOURCE_NODE *
 803 RsDoIoDescriptor (
 804     ACPI_PARSE_OBJECT       *Op,
 805     UINT32                  CurrentByteOffset);
 806
 807 ASL_RESOURCE_NODE *
 808 RsDoIrqDescriptor (
 809     ACPI_PARSE_OBJECT       *Op,
 810     UINT32                  CurrentByteOffset);
 811
 812 ASL_RESOURCE_NODE *
 813 RsDoIrqNoFlagsDescriptor (
 814     ACPI_PARSE_OBJECT       *Op,
 815     UINT32                  CurrentByteOffset);
 816
 817 ASL_RESOURCE_NODE *
 818 RsDoMemory24Descriptor (
 819     ACPI_PARSE_OBJECT       *Op,
 820     UINT32                  CurrentByteOffset);
 821
 822 ASL_RESOURCE_NODE *
 823 RsDoMemory32Descriptor (
 824     ACPI_PARSE_OBJECT       *Op,
 825     UINT32                  CurrentByteOffset);
 826
 827 ASL_RESOURCE_NODE *
 828 RsDoMemory32FixedDescriptor (
 829     ACPI_PARSE_OBJECT       *Op,
 830     UINT32                  CurrentByteOffset);
 831
 832 ASL_RESOURCE_NODE *
 833 RsDoStartDependentDescriptor (
 834     ACPI_PARSE_OBJECT       *Op,
 835     UINT32                  CurrentByteOffset);
 836
 837 ASL_RESOURCE_NODE *
 838 RsDoStartDependentNoPriDescriptor (
 839     ACPI_PARSE_OBJECT       *Op,
 840     UINT32                  CurrentByteOffset);
 841
 842 ASL_RESOURCE_NODE *
 843 RsDoVendorSmallDescriptor (
 844     ACPI_PARSE_OBJECT       *Op,
 845     UINT32                  CurrentByteOffset);
 846
 847
 848 /*
 849  * aslrestype2 - generate Large descriptors
 850  */
 851 ASL_RESOURCE_NODE *
 852 RsDoInterruptDescriptor (
 853     ACPI_PARSE_OBJECT       *Op,
 854     UINT32                  CurrentByteOffset);
 855
 856 ASL_RESOURCE_NODE *
 857 RsDoDwordIoDescriptor (
 858     ACPI_PARSE_OBJECT       *Op,
 859     UINT32                  CurrentByteOffset);
 860
 861 ASL_RESOURCE_NODE *
 862 RsDoDwordMemoryDescriptor (
 863     ACPI_PARSE_OBJECT       *Op,
 864     UINT32                  CurrentByteOffset);
 865
 866 ASL_RESOURCE_NODE *
 867 RsDoDwordSpaceDescriptor (
 868     ACPI_PARSE_OBJECT       *Op,
 869     UINT32                  CurrentByteOffset);
 870
 871 ASL_RESOURCE_NODE *
 872 RsDoExtendedIoDescriptor (
 873     ACPI_PARSE_OBJECT       *Op,
 874     UINT32                  CurrentByteOffset);
 875
 876 ASL_RESOURCE_NODE *
 877 RsDoExtendedMemoryDescriptor (
 878     ACPI_PARSE_OBJECT       *Op,
 879     UINT32                  CurrentByteOffset);
 880
 881 ASL_RESOURCE_NODE *
 882 RsDoExtendedSpaceDescriptor (
 883     ACPI_PARSE_OBJECT       *Op,
 884     UINT32                  CurrentByteOffset);
 885
 886 ASL_RESOURCE_NODE *
 887 RsDoQwordIoDescriptor (
 888     ACPI_PARSE_OBJECT       *Op,
 889     UINT32                  CurrentByteOffset);
 890
 891 ASL_RESOURCE_NODE *
 892 RsDoQwordMemoryDescriptor (
 893     ACPI_PARSE_OBJECT       *Op,
 894     UINT32                  CurrentByteOffset);
 895
 896 ASL_RESOURCE_NODE *
 897 RsDoQwordSpaceDescriptor (
 898     ACPI_PARSE_OBJECT       *Op,
 899     UINT32                  CurrentByteOffset);
 900
 901 ASL_RESOURCE_NODE *
 902 RsDoWordIoDescriptor (
 903     ACPI_PARSE_OBJECT       *Op,
 904     UINT32                  CurrentByteOffset);
 905
 906 ASL_RESOURCE_NODE *
 907 RsDoWordSpaceDescriptor (
 908     ACPI_PARSE_OBJECT       *Op,
 909     UINT32                  CurrentByteOffset);
 910
 911 ASL_RESOURCE_NODE *
 912 RsDoWordBusNumberDescriptor (
 913     ACPI_PARSE_OBJECT       *Op,
 914     UINT32                  CurrentByteOffset);
 915
 916 ASL_RESOURCE_NODE *
 917 RsDoVendorLargeDescriptor (
 918     ACPI_PARSE_OBJECT       *Op,
 919     UINT32                  CurrentByteOffset);
 920
 921 ASL_RESOURCE_NODE *
 922 RsDoGeneralRegisterDescriptor (
 923     ACPI_PARSE_OBJECT       *Op,
 924     UINT32                  CurrentByteOffset);
 925
 926 #endif /*  __ASLCOMPILER_H */
 927