sys/contrib/dev/acpica/compiler/aslcompiler.h

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