sys/contrib/dev/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 - 2010, 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 <contrib/dev/acpica/include/acpi.h>
 142 #include <contrib/dev/acpica/include/accommon.h>
 143 #include <contrib/dev/acpica/include/amlresrc.h>
 144 #include <contrib/dev/acpica/include/acdebug.h>
 145
 146 /* Compiler headers */
 147
 148 #include <contrib/dev/acpica/compiler/asldefine.h>
 149 #include <contrib/dev/acpica/compiler/asltypes.h>
 150 #include <contrib/dev/acpica/compiler/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
 456 /*
 457  * aslpredef - ACPI predefined names support
 458  */
 459 void
 460 ApCheckForPredefinedMethod (
 461     ACPI_PARSE_OBJECT       *Op,
 462     ASL_METHOD_INFO         *MethodInfo);
 463
 464 void
 465 ApCheckPredefinedReturnValue (
 466     ACPI_PARSE_OBJECT       *Op,
 467     ASL_METHOD_INFO         *MethodInfo);
 468
 469 UINT32
 470 ApCheckForPredefinedName (
 471     ACPI_PARSE_OBJECT       *Op,
 472     char                    *Name);
 473
 474 void
 475 ApCheckForPredefinedObject (
 476     ACPI_PARSE_OBJECT       *Op,
 477     char                    *Name);
 478
 479 void
 480 ApDisplayReservedNames (
 481     void);
 482
 483
 484 /*
 485  * asltransform - parse tree transformations
 486  */
 487 ACPI_STATUS
 488 TrAmlTransformWalk (
 489     ACPI_PARSE_OBJECT       *Op,
 490     UINT32                  Level,
 491     void                    *Context);
 492
 493
 494 /*
 495  * asltree - parse tree support
 496  */
 497 ACPI_STATUS
 498 TrWalkParseTree (
 499     ACPI_PARSE_OBJECT       *Op,
 500     UINT32                  Visitation,
 501     ASL_WALK_CALLBACK       DescendingCallback,
 502     ASL_WALK_CALLBACK       AscendingCallback,
 503     void                    *Context);
 504
 505 /* Values for "Visitation" parameter above */
 506
 507 #define ASL_WALK_VISIT_DOWNWARD     0x01
 508 #define ASL_WALK_VISIT_UPWARD       0x02
 509 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 510
 511
 512 ACPI_PARSE_OBJECT *
 513 TrAllocateNode (
 514     UINT32                  ParseOpcode);
 515
 516 void
 517 TrReleaseNode (
 518     ACPI_PARSE_OBJECT       *Op);
 519
 520 ACPI_PARSE_OBJECT *
 521 TrUpdateNode (
 522     UINT32                  ParseOpcode,
 523     ACPI_PARSE_OBJECT       *Op);
 524
 525 ACPI_PARSE_OBJECT *
 526 TrCreateNode (
 527     UINT32                  ParseOpcode,
 528     UINT32                  NumChildren,
 529     ...);
 530
 531 ACPI_PARSE_OBJECT *
 532 TrCreateLeafNode (
 533     UINT32                  ParseOpcode);
 534
 535 ACPI_PARSE_OBJECT *
 536 TrCreateValuedLeafNode (
 537     UINT32                  ParseOpcode,
 538     UINT64                  Value);
 539
 540 ACPI_PARSE_OBJECT *
 541 TrLinkChildren (
 542     ACPI_PARSE_OBJECT       *Op,
 543     UINT32                  NumChildren,
 544     ...);
 545
 546 void
 547 TrSetEndLineNumber (
 548     ACPI_PARSE_OBJECT       *Op);
 549
 550 void
 551 TrWalkTree (
 552     void);
 553
 554 ACPI_PARSE_OBJECT *
 555 TrLinkPeerNode (
 556     ACPI_PARSE_OBJECT       *Op1,
 557     ACPI_PARSE_OBJECT       *Op2);
 558
 559 ACPI_PARSE_OBJECT *
 560 TrLinkChildNode (
 561     ACPI_PARSE_OBJECT       *Op1,
 562     ACPI_PARSE_OBJECT       *Op2);
 563
 564 ACPI_PARSE_OBJECT *
 565 TrSetNodeFlags (
 566     ACPI_PARSE_OBJECT       *Op,
 567     UINT32                  Flags);
 568
 569 ACPI_PARSE_OBJECT *
 570 TrLinkPeerNodes (
 571     UINT32                  NumPeers,
 572     ...);
 573
 574
 575 /*
 576  * aslfiles - File I/O support
 577  */
 578 void
 579 AslAbort (
 580     void);
 581
 582 void
 583 FlAddIncludeDirectory (
 584     char                    *Dir);
 585
 586 void
 587 FlOpenIncludeFile (
 588     ACPI_PARSE_OBJECT       *Op);
 589
 590 void
 591 FlFileError (
 592     UINT32                  FileId,
 593     UINT8                   ErrorId);
 594
 595 ACPI_STATUS
 596 FlReadFile (
 597     UINT32                  FileId,
 598     void                    *Buffer,
 599     UINT32                  Length);
 600
 601 void
 602 FlWriteFile (
 603     UINT32                  FileId,
 604     void                    *Buffer,
 605     UINT32                  Length);
 606
 607 void
 608 FlSeekFile (
 609     UINT32                  FileId,
 610     long                    Offset);
 611
 612 void
 613 FlCloseFile (
 614     UINT32                  FileId);
 615
 616 void
 617 FlPrintFile (
 618     UINT32                  FileId,
 619     char                    *Format,
 620     ...);
 621
 622 void
 623 FlSetLineNumber (
 624     ACPI_PARSE_OBJECT       *Op);
 625
 626 ACPI_STATUS
 627 FlOpenInputFile (
 628     char                    *InputFilename);
 629
 630 ACPI_STATUS
 631 FlOpenAmlOutputFile (
 632     char                    *InputFilename);
 633
 634 ACPI_STATUS
 635 FlOpenMiscOutputFiles (
 636     char                    *InputFilename);
 637
 638
 639 /*
 640  * asload - load namespace in prep for cross reference
 641  */
 642 ACPI_STATUS
 643 LdLoadNamespace (
 644     ACPI_PARSE_OBJECT       *RootOp);
 645
 646
 647 /*
 648  * asllookup - namespace cross reference
 649  */
 650 ACPI_STATUS
 651 LkCrossReferenceNamespace (
 652     void);
 653
 654 void
 655 LkFindUnreferencedObjects (
 656     void);
 657
 658 ACPI_STATUS
 659 LsDisplayNamespace (
 660     void);
 661
 662
 663 /*
 664  * aslutils - common compiler utilites
 665  */
 666 void
 667 DbgPrint (
 668     UINT32                  Type,
 669     char                    *Format,
 670     ...);
 671
 672 /* Type values for above */
 673
 674 #define ASL_DEBUG_OUTPUT    0
 675 #define ASL_PARSE_OUTPUT    1
 676 #define ASL_TREE_OUTPUT     2
 677
 678 void
 679 UtDisplayConstantOpcodes (
 680     void);
 681
 682 UINT8
 683 UtBeginEvent (
 684     char                    *Name);
 685
 686 void
 687 UtEndEvent (
 688     UINT8                   Event);
 689
 690 void *
 691 UtLocalCalloc (
 692     UINT32                  Size);
 693
 694 void
 695 UtPrintFormattedName (
 696     UINT16                  ParseOpcode,
 697     UINT32                  Level);
 698
 699 void
 700 UtDisplaySummary (
 701     UINT32                  FileId);
 702
 703 UINT8
 704 UtHexCharToValue (
 705     int                     HexChar);
 706
 707 void
 708 UtConvertByteToHex (
 709     UINT8                   RawByte,
 710     UINT8                   *Buffer);
 711
 712 void
 713 UtConvertByteToAsmHex (
 714     UINT8                   RawByte,
 715     UINT8                   *Buffer);
 716
 717 char *
 718 UtGetOpName (
 719     UINT32                  ParseOpcode);
 720
 721 void
 722 UtSetParseOpName (
 723     ACPI_PARSE_OBJECT       *Op);
 724
 725 char *
 726 UtGetStringBuffer (
 727     UINT32                  Length);
 728
 729 ACPI_STATUS
 730 UtInternalizeName (
 731     char                    *ExternalName,
 732     char                    **ConvertedName);
 733
 734 void
 735 UtAttachNamepathToOwner (
 736     ACPI_PARSE_OBJECT       *Op,
 737     ACPI_PARSE_OBJECT       *NameNode);
 738
 739 ACPI_PARSE_OBJECT *
 740 UtCheckIntegerRange (
 741     ACPI_PARSE_OBJECT       *Op,
 742     UINT32                  LowValue,
 743     UINT32                  HighValue);
 744
 745 UINT64
 746 UtDoConstant (
 747     char                    *String);
 748
 749
 750 /*
 751  * aslresource - Resource template generation utilities
 752  */
 753 ASL_RESOURCE_NODE *
 754 RsAllocateResourceNode (
 755     UINT32                  Size);
 756
 757 void
 758 RsCreateBitField (
 759     ACPI_PARSE_OBJECT       *Op,
 760     char                    *Name,
 761     UINT32                  ByteOffset,
 762     UINT32                  BitOffset);
 763
 764 void
 765 RsCreateByteField (
 766     ACPI_PARSE_OBJECT       *Op,
 767     char                    *Name,
 768     UINT32                  ByteOffset);
 769
 770 void
 771 RsSetFlagBits (
 772     UINT8                   *Flags,
 773     ACPI_PARSE_OBJECT       *Op,
 774     UINT8                   Position,
 775     UINT8                   DefaultBit);
 776
 777 ACPI_PARSE_OBJECT *
 778 RsCompleteNodeAndGetNext (
 779     ACPI_PARSE_OBJECT       *Op);
 780
 781 void
 782 RsCheckListForDuplicates (
 783     ACPI_PARSE_OBJECT       *Op);
 784
 785 ASL_RESOURCE_NODE *
 786 RsDoOneResourceDescriptor (
 787     ACPI_PARSE_OBJECT       *DescriptorTypeOp,
 788     UINT32                  CurrentByteOffset,
 789     UINT8                   *State);
 790
 791 /* Values for State above */
 792
 793 #define ACPI_RSTATE_NORMAL              0
 794 #define ACPI_RSTATE_START_DEPENDENT     1
 795 #define ACPI_RSTATE_DEPENDENT_LIST      2
 796
 797 UINT32
 798 RsLinkDescriptorChain (
 799     ASL_RESOURCE_NODE       **PreviousRnode,
 800     ASL_RESOURCE_NODE       *Rnode);
 801
 802 void
 803 RsDoResourceTemplate (
 804     ACPI_PARSE_OBJECT       *Op);
 805
 806
 807 /*
 808  * aslrestype1 - generate Small descriptors
 809  */
 810 ASL_RESOURCE_NODE *
 811 RsDoEndTagDescriptor (
 812     ACPI_PARSE_OBJECT       *Op,
 813     UINT32                  CurrentByteOffset);
 814
 815 ASL_RESOURCE_NODE *
 816 RsDoDmaDescriptor (
 817     ACPI_PARSE_OBJECT       *Op,
 818     UINT32                  CurrentByteOffset);
 819
 820 ASL_RESOURCE_NODE *
 821 RsDoEndDependentDescriptor (
 822     ACPI_PARSE_OBJECT       *Op,
 823     UINT32                  CurrentByteOffset);
 824
 825 ASL_RESOURCE_NODE *
 826 RsDoFixedIoDescriptor (
 827     ACPI_PARSE_OBJECT       *Op,
 828     UINT32                  CurrentByteOffset);
 829
 830 ASL_RESOURCE_NODE *
 831 RsDoIoDescriptor (
 832     ACPI_PARSE_OBJECT       *Op,
 833     UINT32                  CurrentByteOffset);
 834
 835 ASL_RESOURCE_NODE *
 836 RsDoIrqDescriptor (
 837     ACPI_PARSE_OBJECT       *Op,
 838     UINT32                  CurrentByteOffset);
 839
 840 ASL_RESOURCE_NODE *
 841 RsDoIrqNoFlagsDescriptor (
 842     ACPI_PARSE_OBJECT       *Op,
 843     UINT32                  CurrentByteOffset);
 844
 845 ASL_RESOURCE_NODE *
 846 RsDoMemory24Descriptor (
 847     ACPI_PARSE_OBJECT       *Op,
 848     UINT32                  CurrentByteOffset);
 849
 850 ASL_RESOURCE_NODE *
 851 RsDoMemory32Descriptor (
 852     ACPI_PARSE_OBJECT       *Op,
 853     UINT32                  CurrentByteOffset);
 854
 855 ASL_RESOURCE_NODE *
 856 RsDoMemory32FixedDescriptor (
 857     ACPI_PARSE_OBJECT       *Op,
 858     UINT32                  CurrentByteOffset);
 859
 860 ASL_RESOURCE_NODE *
 861 RsDoStartDependentDescriptor (
 862     ACPI_PARSE_OBJECT       *Op,
 863     UINT32                  CurrentByteOffset);
 864
 865 ASL_RESOURCE_NODE *
 866 RsDoStartDependentNoPriDescriptor (
 867     ACPI_PARSE_OBJECT       *Op,
 868     UINT32                  CurrentByteOffset);
 869
 870 ASL_RESOURCE_NODE *
 871 RsDoVendorSmallDescriptor (
 872     ACPI_PARSE_OBJECT       *Op,
 873     UINT32                  CurrentByteOffset);
 874
 875
 876 /*
 877  * aslrestype2 - generate Large descriptors
 878  */
 879 ASL_RESOURCE_NODE *
 880 RsDoInterruptDescriptor (
 881     ACPI_PARSE_OBJECT       *Op,
 882     UINT32                  CurrentByteOffset);
 883
 884 ASL_RESOURCE_NODE *
 885 RsDoDwordIoDescriptor (
 886     ACPI_PARSE_OBJECT       *Op,
 887     UINT32                  CurrentByteOffset);
 888
 889 ASL_RESOURCE_NODE *
 890 RsDoDwordMemoryDescriptor (
 891     ACPI_PARSE_OBJECT       *Op,
 892     UINT32                  CurrentByteOffset);
 893
 894 ASL_RESOURCE_NODE *
 895 RsDoDwordSpaceDescriptor (
 896     ACPI_PARSE_OBJECT       *Op,
 897     UINT32                  CurrentByteOffset);
 898
 899 ASL_RESOURCE_NODE *
 900 RsDoExtendedIoDescriptor (
 901     ACPI_PARSE_OBJECT       *Op,
 902     UINT32                  CurrentByteOffset);
 903
 904 ASL_RESOURCE_NODE *
 905 RsDoExtendedMemoryDescriptor (
 906     ACPI_PARSE_OBJECT       *Op,
 907     UINT32                  CurrentByteOffset);
 908
 909 ASL_RESOURCE_NODE *
 910 RsDoExtendedSpaceDescriptor (
 911     ACPI_PARSE_OBJECT       *Op,
 912     UINT32                  CurrentByteOffset);
 913
 914 ASL_RESOURCE_NODE *
 915 RsDoQwordIoDescriptor (
 916     ACPI_PARSE_OBJECT       *Op,
 917     UINT32                  CurrentByteOffset);
 918
 919 ASL_RESOURCE_NODE *
 920 RsDoQwordMemoryDescriptor (
 921     ACPI_PARSE_OBJECT       *Op,
 922     UINT32                  CurrentByteOffset);
 923
 924 ASL_RESOURCE_NODE *
 925 RsDoQwordSpaceDescriptor (
 926     ACPI_PARSE_OBJECT       *Op,
 927     UINT32                  CurrentByteOffset);
 928
 929 ASL_RESOURCE_NODE *
 930 RsDoWordIoDescriptor (
 931     ACPI_PARSE_OBJECT       *Op,
 932     UINT32                  CurrentByteOffset);
 933
 934 ASL_RESOURCE_NODE *
 935 RsDoWordSpaceDescriptor (
 936     ACPI_PARSE_OBJECT       *Op,
 937     UINT32                  CurrentByteOffset);
 938
 939 ASL_RESOURCE_NODE *
 940 RsDoWordBusNumberDescriptor (
 941     ACPI_PARSE_OBJECT       *Op,
 942     UINT32                  CurrentByteOffset);
 943
 944 ASL_RESOURCE_NODE *
 945 RsDoVendorLargeDescriptor (
 946     ACPI_PARSE_OBJECT       *Op,
 947     UINT32                  CurrentByteOffset);
 948
 949 ASL_RESOURCE_NODE *
 950 RsDoGeneralRegisterDescriptor (
 951     ACPI_PARSE_OBJECT       *Op,
 952     UINT32                  CurrentByteOffset);
 953
 954 #endif /*  __ASLCOMPILER_H */
 955