Home | History | Annotate | Line # | Download | only in compiler
aslcompiler.h revision 1.1.1.3 
      1 
      2 /******************************************************************************
      3  *
      4  * Module Name: aslcompiler.h - common include file for iASL
      5  *
      6  *****************************************************************************/
      7 
      8 /*
      9  * Copyright (C) 2000 - 2011, Intel Corp.
     10  * All rights reserved.
     11  *
     12  * Redistribution and use in source and binary forms, with or without
     13  * modification, are permitted provided that the following conditions
     14  * are met:
     15  * 1. Redistributions of source code must retain the above copyright
     16  *    notice, this list of conditions, and the following disclaimer,
     17  *    without modification.
     18  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
     19  *    substantially similar to the "NO WARRANTY" disclaimer below
     20  *    ("Disclaimer") and any redistribution must be conditioned upon
     21  *    including a substantially similar Disclaimer requirement for further
     22  *    binary redistribution.
     23  * 3. Neither the names of the above-listed copyright holders nor the names
     24  *    of any contributors may be used to endorse or promote products derived
     25  *    from this software without specific prior written permission.
     26  *
     27  * Alternatively, this software may be distributed under the terms of the
     28  * GNU General Public License ("GPL") version 2 as published by the Free
     29  * Software Foundation.
     30  *
     31  * NO WARRANTY
     32  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     33  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     34  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
     35  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     36  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     37  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     38  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     39  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     40  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
     41  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     42  * POSSIBILITY OF SUCH DAMAGES.
     43  */
     44 
     45 
     46 #ifndef __ASLCOMPILER_H
     47 #define __ASLCOMPILER_H
     48 
     49 #include "acpi.h"
     50 #include "accommon.h"
     51 #include "amlresrc.h"
     52 #include "acdebug.h"
     53 
     54 /* Microsoft-specific */
     55 
     56 #if (defined WIN32 || defined WIN64)
     57 
     58 /* warn : used #pragma pack */
     59 #pragma warning(disable:4103)
     60 
     61 /* warn : named type definition in parentheses */
     62 #pragma warning(disable:4115)
     63 #endif
     64 
     65 #include <stdio.h>
     66 #include <stdlib.h>
     67 #include <stdarg.h>
     68 #include <string.h>
     69 #include <errno.h>
     70 #include <ctype.h>
     71 
     72 /* Compiler headers */
     73 
     74 #include "asldefine.h"
     75 #include "asltypes.h"
     76 #include "aslmessages.h"
     77 #include "aslglobal.h"
     78 
     79 
     80 /*******************************************************************************
     81  *
     82  * Compiler prototypes
     83  *
     84  ******************************************************************************/
     85 
     86 /*
     87  * parser - generated from flex/bison, lex/yacc, etc.
     88  */
     89 int
     90 AslCompilerparse(
     91     void);
     92 
     93 ACPI_PARSE_OBJECT *
     94 AslDoError (
     95     void);
     96 
     97 int
     98 AslCompilerlex(
     99     void);
    100 
    101 void
    102 ResetCurrentLineBuffer (
    103     void);
    104 
    105 void
    106 InsertLineBuffer (
    107     int                     SourceChar);
    108 
    109 int
    110 AslPopInputFileStack (
    111     void);
    112 
    113 void
    114 AslPushInputFileStack (
    115     FILE                    *InputFile,
    116     char                    *Filename);
    117 
    118 /*
    119  * aslstartup - entered from main()
    120  */
    121 void
    122 AslInitializeGlobals (
    123     void);
    124 
    125 typedef
    126 ACPI_STATUS (*ASL_PATHNAME_CALLBACK) (
    127     char *);
    128 
    129 ACPI_STATUS
    130 AslDoOnePathname (
    131     char                    *Pathname,
    132     ASL_PATHNAME_CALLBACK   Callback);
    133 
    134 ACPI_STATUS
    135 AslDoOneFile (
    136     char                    *Filename);
    137 
    138 /*
    139  * aslcompile - compile mainline
    140  */
    141 void
    142 AslCompilerSignon (
    143     UINT32                  FileId);
    144 
    145 void
    146 AslCompilerFileHeader (
    147     UINT32                  FileId);
    148 
    149 int
    150 CmDoCompile (
    151     void);
    152 
    153 void
    154 CmDoOutputFiles (
    155     void);
    156 
    157 void
    158 CmCleanupAndExit (
    159     void);
    160 
    161 ACPI_STATUS
    162 FlCheckForAscii (
    163     ASL_FILE_INFO           *FileInfo);
    164 
    165 
    166 /*
    167  * aslwalks - semantic analysis and parse tree walks
    168  */
    169 ACPI_STATUS
    170 AnOtherSemanticAnalysisWalkBegin (
    171     ACPI_PARSE_OBJECT       *Op,
    172     UINT32                  Level,
    173     void                    *Context);
    174 
    175 ACPI_STATUS
    176 AnOtherSemanticAnalysisWalkEnd (
    177     ACPI_PARSE_OBJECT       *Op,
    178     UINT32                  Level,
    179     void                    *Context);
    180 
    181 ACPI_STATUS
    182 AnOperandTypecheckWalkEnd (
    183     ACPI_PARSE_OBJECT       *Op,
    184     UINT32                  Level,
    185     void                    *Context);
    186 
    187 ACPI_STATUS
    188 AnMethodAnalysisWalkBegin (
    189     ACPI_PARSE_OBJECT       *Op,
    190     UINT32                  Level,
    191     void                    *Context);
    192 
    193 ACPI_STATUS
    194 AnMethodAnalysisWalkEnd (
    195     ACPI_PARSE_OBJECT       *Op,
    196     UINT32                  Level,
    197     void                    *Context);
    198 
    199 ACPI_STATUS
    200 AnMethodTypingWalkEnd (
    201     ACPI_PARSE_OBJECT       *Op,
    202     UINT32                  Level,
    203     void                    *Context);
    204 
    205 
    206 /*
    207  * aslbtypes - bitfield data types
    208  */
    209 UINT32
    210 AnMapObjTypeToBtype (
    211     ACPI_PARSE_OBJECT       *Op);
    212 
    213 UINT32
    214 AnMapArgTypeToBtype (
    215     UINT32                  ArgType);
    216 
    217 UINT32
    218 AnGetBtype (
    219     ACPI_PARSE_OBJECT       *Op);
    220 
    221 void
    222 AnFormatBtype (
    223     char                    *Buffer,
    224     UINT32                  Btype);
    225 
    226 
    227 /*
    228  * aslanalyze - Support functions for parse tree walks
    229  */
    230 void
    231 AnCheckId (
    232     ACPI_PARSE_OBJECT       *Op,
    233     ACPI_NAME               Type);
    234 
    235 /* Values for Type argument above */
    236 
    237 #define ASL_TYPE_HID        0
    238 #define ASL_TYPE_CID        1
    239 
    240 BOOLEAN
    241 AnIsInternalMethod (
    242     ACPI_PARSE_OBJECT       *Op);
    243 
    244 UINT32
    245 AnGetInternalMethodReturnType (
    246     ACPI_PARSE_OBJECT       *Op);
    247 
    248 BOOLEAN
    249 AnLastStatementIsReturn (
    250     ACPI_PARSE_OBJECT       *Op);
    251 
    252 void
    253 AnCheckMethodReturnValue (
    254     ACPI_PARSE_OBJECT       *Op,
    255     const ACPI_OPCODE_INFO  *OpInfo,
    256     ACPI_PARSE_OBJECT       *ArgOp,
    257     UINT32                  RequiredBtypes,
    258     UINT32                  ThisNodeBtype);
    259 
    260 BOOLEAN
    261 AnIsResultUsed (
    262     ACPI_PARSE_OBJECT       *Op);
    263 
    264 void
    265 ApCheckForGpeNameConflict (
    266     ACPI_PARSE_OBJECT       *Op);
    267 
    268 void
    269 ApCheckRegMethod (
    270     ACPI_PARSE_OBJECT       *Op);
    271 
    272 
    273 /*
    274  * aslerror - error handling/reporting
    275  */
    276 void
    277 AslError (
    278     UINT8                   Level,
    279     UINT8                   MessageId,
    280     ACPI_PARSE_OBJECT       *Op,
    281     char                    *ExtraMessage);
    282 
    283 void
    284 AslCoreSubsystemError (
    285     ACPI_PARSE_OBJECT       *Op,
    286     ACPI_STATUS             Status,
    287     char                    *ExtraMessage,
    288     BOOLEAN                 Abort);
    289 
    290 int
    291 AslCompilererror(
    292     const char              *s);
    293 
    294 void
    295 AslCommonError (
    296     UINT8                   Level,
    297     UINT8                   MessageId,
    298     UINT32                  CurrentLineNumber,
    299     UINT32                  LogicalLineNumber,
    300     UINT32                  LogicalByteOffset,
    301     UINT32                  Column,
    302     char                    *Filename,
    303     char                    *ExtraMessage);
    304 
    305 void
    306 AePrintException (
    307     UINT32                  FileId,
    308     ASL_ERROR_MSG           *Enode,
    309     char                    *Header);
    310 
    311 void
    312 AePrintErrorLog (
    313     UINT32                  FileId);
    314 
    315 void
    316 AeClearErrorLog (
    317     void);
    318 
    319 ACPI_PHYSICAL_ADDRESS
    320 AeLocalGetRootPointer (
    321     void);
    322 
    323 
    324 /*
    325  * asllisting - generate all "listing" type files
    326  */
    327 void
    328 LsDoListings (
    329     void);
    330 
    331 void
    332 LsWriteNodeToAsmListing (
    333     ACPI_PARSE_OBJECT       *Op);
    334 
    335 void
    336 LsWriteNode (
    337     ACPI_PARSE_OBJECT       *Op,
    338     UINT32                  FileId);
    339 
    340 void
    341 LsDoHexOutput (
    342     void);
    343 
    344 void
    345 LsDumpParseTree (
    346     void);
    347 
    348 /*
    349  * aslfold - constant folding
    350  */
    351 ACPI_STATUS
    352 OpcAmlConstantWalk (
    353     ACPI_PARSE_OBJECT       *Op,
    354     UINT32                  Level,
    355     void                    *Context);
    356 
    357 
    358 /*
    359  * aslopcodes - generate AML opcodes
    360  */
    361 ACPI_STATUS
    362 OpcAmlOpcodeWalk (
    363     ACPI_PARSE_OBJECT       *Op,
    364     UINT32                  Level,
    365     void                    *Context);
    366 
    367 ACPI_STATUS
    368 OpcAmlOpcodeUpdateWalk (
    369     ACPI_PARSE_OBJECT       *Op,
    370     UINT32                  Level,
    371     void                    *Context);
    372 
    373 void
    374 OpcGenerateAmlOpcode (
    375     ACPI_PARSE_OBJECT       *Op);
    376 
    377 UINT32
    378 OpcSetOptimalIntegerSize (
    379     ACPI_PARSE_OBJECT       *Op);
    380 
    381 void
    382 OpcGetIntegerWidth (
    383     ACPI_PARSE_OBJECT       *Op);
    384 
    385 
    386 /*
    387  * asloperands - generate AML operands for the AML opcodes
    388  */
    389 ACPI_PARSE_OBJECT  *
    390 UtGetArg (
    391     ACPI_PARSE_OBJECT       *Op,
    392     UINT32                  Argn);
    393 
    394 void
    395 OpnGenerateAmlOperands (
    396     ACPI_PARSE_OBJECT       *Op);
    397 
    398 void
    399 OpnDoPackage (
    400     ACPI_PARSE_OBJECT       *Op);
    401 
    402 
    403 /*
    404  * aslopt - optmization
    405  */
    406 void
    407 OptOptimizeNamePath (
    408     ACPI_PARSE_OBJECT       *Op,
    409     UINT32                  Flags,
    410     ACPI_WALK_STATE         *WalkState,
    411     char                    *AmlNameString,
    412     ACPI_NAMESPACE_NODE     *TargetNode);
    413 
    414 
    415 /*
    416  * aslcodegen - code generation
    417  */
    418 void
    419 CgGenerateAmlOutput (
    420     void);
    421 
    422 
    423 /*
    424  * aslfile
    425  */
    426 void
    427 FlOpenFile (
    428     UINT32                  FileId,
    429     char                    *Filename,
    430     char                    *Mode);
    431 
    432 
    433 /*
    434  * asllength - calculate/adjust AML package lengths
    435  */
    436 ACPI_STATUS
    437 LnPackageLengthWalk (
    438     ACPI_PARSE_OBJECT       *Op,
    439     UINT32                  Level,
    440     void                    *Context);
    441 
    442 ACPI_STATUS
    443 LnInitLengthsWalk (
    444     ACPI_PARSE_OBJECT       *Op,
    445     UINT32                  Level,
    446     void                    *Context);
    447 
    448 void
    449 CgGenerateAmlLengths (
    450     ACPI_PARSE_OBJECT       *Op);
    451 
    452 
    453 /*
    454  * aslmap - opcode mappings and reserved method names
    455  */
    456 ACPI_OBJECT_TYPE
    457 AslMapNamedOpcodeToDataType (
    458     UINT16                  Opcode);
    459 
    460 
    461 /*
    462  * aslpredef - ACPI predefined names support
    463  */
    464 BOOLEAN
    465 ApCheckForPredefinedMethod (
    466     ACPI_PARSE_OBJECT       *Op,
    467     ASL_METHOD_INFO         *MethodInfo);
    468 
    469 void
    470 ApCheckPredefinedReturnValue (
    471     ACPI_PARSE_OBJECT       *Op,
    472     ASL_METHOD_INFO         *MethodInfo);
    473 
    474 UINT32
    475 ApCheckForPredefinedName (
    476     ACPI_PARSE_OBJECT       *Op,
    477     char                    *Name);
    478 
    479 void
    480 ApCheckForPredefinedObject (
    481     ACPI_PARSE_OBJECT       *Op,
    482     char                    *Name);
    483 
    484 void
    485 ApDisplayReservedNames (
    486     void);
    487 
    488 
    489 /*
    490  * asltransform - parse tree transformations
    491  */
    492 ACPI_STATUS
    493 TrAmlTransformWalk (
    494     ACPI_PARSE_OBJECT       *Op,
    495     UINT32                  Level,
    496     void                    *Context);
    497 
    498 
    499 /*
    500  * asltree - parse tree support
    501  */
    502 ACPI_STATUS
    503 TrWalkParseTree (
    504     ACPI_PARSE_OBJECT       *Op,
    505     UINT32                  Visitation,
    506     ASL_WALK_CALLBACK       DescendingCallback,
    507     ASL_WALK_CALLBACK       AscendingCallback,
    508     void                    *Context);
    509 
    510 /* Values for "Visitation" parameter above */
    511 
    512 #define ASL_WALK_VISIT_DOWNWARD     0x01
    513 #define ASL_WALK_VISIT_UPWARD       0x02
    514 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
    515 
    516 
    517 ACPI_PARSE_OBJECT *
    518 TrAllocateNode (
    519     UINT32                  ParseOpcode);
    520 
    521 void
    522 TrReleaseNode (
    523     ACPI_PARSE_OBJECT       *Op);
    524 
    525 ACPI_PARSE_OBJECT *
    526 TrUpdateNode (
    527     UINT32                  ParseOpcode,
    528     ACPI_PARSE_OBJECT       *Op);
    529 
    530 ACPI_PARSE_OBJECT *
    531 TrCreateNode (
    532     UINT32                  ParseOpcode,
    533     UINT32                  NumChildren,
    534     ...);
    535 
    536 ACPI_PARSE_OBJECT *
    537 TrCreateLeafNode (
    538     UINT32                  ParseOpcode);
    539 
    540 ACPI_PARSE_OBJECT *
    541 TrCreateValuedLeafNode (
    542     UINT32                  ParseOpcode,
    543     UINT64                  Value);
    544 
    545 ACPI_PARSE_OBJECT *
    546 TrCreateConstantLeafNode (
    547     UINT32                  ParseOpcode);
    548 
    549 ACPI_PARSE_OBJECT *
    550 TrLinkChildren (
    551     ACPI_PARSE_OBJECT       *Op,
    552     UINT32                  NumChildren,
    553     ...);
    554 
    555 void
    556 TrSetEndLineNumber (
    557     ACPI_PARSE_OBJECT       *Op);
    558 
    559 void
    560 TrWalkTree (
    561     void);
    562 
    563 ACPI_PARSE_OBJECT *
    564 TrLinkPeerNode (
    565     ACPI_PARSE_OBJECT       *Op1,
    566     ACPI_PARSE_OBJECT       *Op2);
    567 
    568 ACPI_PARSE_OBJECT *
    569 TrLinkChildNode (
    570     ACPI_PARSE_OBJECT       *Op1,
    571     ACPI_PARSE_OBJECT       *Op2);
    572 
    573 ACPI_PARSE_OBJECT *
    574 TrSetNodeFlags (
    575     ACPI_PARSE_OBJECT       *Op,
    576     UINT32                  Flags);
    577 
    578 ACPI_PARSE_OBJECT *
    579 TrLinkPeerNodes (
    580     UINT32                  NumPeers,
    581     ...);
    582 
    583 
    584 /*
    585  * aslfiles - File I/O support
    586  */
    587 void
    588 AslAbort (
    589     void);
    590 
    591 void
    592 FlAddIncludeDirectory (
    593     char                    *Dir);
    594 
    595 void
    596 FlOpenIncludeFile (
    597     ACPI_PARSE_OBJECT       *Op);
    598 
    599 void
    600 FlFileError (
    601     UINT32                  FileId,
    602     UINT8                   ErrorId);
    603 
    604 UINT32
    605 FlGetFileSize (
    606     UINT32                  FileId);
    607 
    608 ACPI_STATUS
    609 FlReadFile (
    610     UINT32                  FileId,
    611     void                    *Buffer,
    612     UINT32                  Length);
    613 
    614 void
    615 FlWriteFile (
    616     UINT32                  FileId,
    617     void                    *Buffer,
    618     UINT32                  Length);
    619 
    620 void
    621 FlSeekFile (
    622     UINT32                  FileId,
    623     long                    Offset);
    624 
    625 void
    626 FlCloseFile (
    627     UINT32                  FileId);
    628 
    629 void
    630 FlPrintFile (
    631     UINT32                  FileId,
    632     char                    *Format,
    633     ...);
    634 
    635 void
    636 FlSetLineNumber (
    637     ACPI_PARSE_OBJECT       *Op);
    638 
    639 ACPI_STATUS
    640 FlOpenInputFile (
    641     char                    *InputFilename);
    642 
    643 ACPI_STATUS
    644 FlOpenAmlOutputFile (
    645     char                    *InputFilename);
    646 
    647 ACPI_STATUS
    648 FlOpenMiscOutputFiles (
    649     char                    *InputFilename);
    650 
    651 
    652 /*
    653  * asload - load namespace in prep for cross reference
    654  */
    655 ACPI_STATUS
    656 LdLoadNamespace (
    657     ACPI_PARSE_OBJECT       *RootOp);
    658 
    659 
    660 /*
    661  * asllookup - namespace cross reference
    662  */
    663 ACPI_STATUS
    664 LkCrossReferenceNamespace (
    665     void);
    666 
    667 void
    668 LkFindUnreferencedObjects (
    669     void);
    670 
    671 ACPI_STATUS
    672 LsDisplayNamespace (
    673     void);
    674 
    675 void
    676 LsSetupNsList (
    677     void                    *Handle);
    678 
    679 
    680 /*
    681  * aslutils - common compiler utilites
    682  */
    683 void
    684 DbgPrint (
    685     UINT32                  Type,
    686     char                    *Format,
    687     ...);
    688 
    689 /* Type values for above */
    690 
    691 #define ASL_DEBUG_OUTPUT    0
    692 #define ASL_PARSE_OUTPUT    1
    693 #define ASL_TREE_OUTPUT     2
    694 
    695 void
    696 UtDisplaySupportedTables (
    697     void);
    698 
    699 void
    700 UtDisplayConstantOpcodes (
    701     void);
    702 
    703 UINT8
    704 UtBeginEvent (
    705     char                    *Name);
    706 
    707 void
    708 UtEndEvent (
    709     UINT8                   Event);
    710 
    711 void *
    712 UtLocalCalloc (
    713     UINT32                  Size);
    714 
    715 void
    716 UtPrintFormattedName (
    717     UINT16                  ParseOpcode,
    718     UINT32                  Level);
    719 
    720 void
    721 UtDisplaySummary (
    722     UINT32                  FileId);
    723 
    724 UINT8
    725 UtHexCharToValue (
    726     int                     HexChar);
    727 
    728 void
    729 UtConvertByteToHex (
    730     UINT8                   RawByte,
    731     UINT8                   *Buffer);
    732 
    733 void
    734 UtConvertByteToAsmHex (
    735     UINT8                   RawByte,
    736     UINT8                   *Buffer);
    737 
    738 char *
    739 UtGetOpName (
    740     UINT32                  ParseOpcode);
    741 
    742 void
    743 UtSetParseOpName (
    744     ACPI_PARSE_OBJECT       *Op);
    745 
    746 char *
    747 UtGetStringBuffer (
    748     UINT32                  Length);
    749 
    750 ACPI_STATUS
    751 UtInternalizeName (
    752     char                    *ExternalName,
    753     char                    **ConvertedName);
    754 
    755 void
    756 UtAttachNamepathToOwner (
    757     ACPI_PARSE_OBJECT       *Op,
    758     ACPI_PARSE_OBJECT       *NameNode);
    759 
    760 ACPI_PARSE_OBJECT *
    761 UtCheckIntegerRange (
    762     ACPI_PARSE_OBJECT       *Op,
    763     UINT32                  LowValue,
    764     UINT32                  HighValue);
    765 
    766 UINT64
    767 UtDoConstant (
    768     char                    *String);
    769 
    770 ACPI_STATUS
    771 UtStrtoul64 (
    772     char                    *String,
    773     UINT32                  Base,
    774     UINT64                  *RetInteger);
    775 
    776 
    777 /*
    778  * asluuid - UUID support
    779  */
    780 ACPI_STATUS
    781 AuValidateUuid (
    782     char                    *InString);
    783 
    784 ACPI_STATUS
    785 AuConvertStringToUuid (
    786     char                    *InString,
    787     char                    *UuIdBuffer);
    788 
    789 ACPI_STATUS
    790 AuConvertUuidToString (
    791     char                    *UuIdBuffer,
    792     char                    *OutString);
    793 
    794 /*
    795  * aslresource - Resource template generation utilities
    796  */
    797 void
    798 RsSmallAddressCheck (
    799     UINT8                   Type,
    800     UINT32                  Minimum,
    801     UINT32                  Maximum,
    802     UINT32                  Length,
    803     UINT32                  Alignment,
    804     ACPI_PARSE_OBJECT       *MinOp,
    805     ACPI_PARSE_OBJECT       *MaxOp,
    806     ACPI_PARSE_OBJECT       *LengthOp,
    807     ACPI_PARSE_OBJECT       *AlignOp,
    808     ACPI_PARSE_OBJECT       *Op);
    809 
    810 void
    811 RsLargeAddressCheck (
    812     UINT64                  Minimum,
    813     UINT64                  Maximum,
    814     UINT64                  Length,
    815     UINT64                  Granularity,
    816     UINT8                   Flags,
    817     ACPI_PARSE_OBJECT       *MinOp,
    818     ACPI_PARSE_OBJECT       *MaxOp,
    819     ACPI_PARSE_OBJECT       *LengthOp,
    820     ACPI_PARSE_OBJECT       *GranOp,
    821     ACPI_PARSE_OBJECT       *Op);
    822 
    823 UINT16
    824 RsGetStringDataLength (
    825     ACPI_PARSE_OBJECT       *InitializerOp);
    826 
    827 ASL_RESOURCE_NODE *
    828 RsAllocateResourceNode (
    829     UINT32                  Size);
    830 
    831 void
    832 RsCreateBitField (
    833     ACPI_PARSE_OBJECT       *Op,
    834     char                    *Name,
    835     UINT32                  ByteOffset,
    836     UINT32                  BitOffset);
    837 
    838 void
    839 RsCreateByteField (
    840     ACPI_PARSE_OBJECT       *Op,
    841     char                    *Name,
    842     UINT32                  ByteOffset);
    843 
    844 void
    845 RsSetFlagBits (
    846     UINT8                   *Flags,
    847     ACPI_PARSE_OBJECT       *Op,
    848     UINT8                   Position,
    849     UINT8                   DefaultBit);
    850 
    851 ACPI_PARSE_OBJECT *
    852 RsCompleteNodeAndGetNext (
    853     ACPI_PARSE_OBJECT       *Op);
    854 
    855 void
    856 RsCheckListForDuplicates (
    857     ACPI_PARSE_OBJECT       *Op);
    858 
    859 ASL_RESOURCE_NODE *
    860 RsDoOneResourceDescriptor (
    861     ACPI_PARSE_OBJECT       *DescriptorTypeOp,
    862     UINT32                  CurrentByteOffset,
    863     UINT8                   *State);
    864 
    865 /* Values for State above */
    866 
    867 #define ACPI_RSTATE_NORMAL              0
    868 #define ACPI_RSTATE_START_DEPENDENT     1
    869 #define ACPI_RSTATE_DEPENDENT_LIST      2
    870 
    871 UINT32
    872 RsLinkDescriptorChain (
    873     ASL_RESOURCE_NODE       **PreviousRnode,
    874     ASL_RESOURCE_NODE       *Rnode);
    875 
    876 void
    877 RsDoResourceTemplate (
    878     ACPI_PARSE_OBJECT       *Op);
    879 
    880 
    881 /*
    882  * aslrestype1 - Miscellaneous Small descriptors
    883  */
    884 ASL_RESOURCE_NODE *
    885 RsDoEndTagDescriptor (
    886     ACPI_PARSE_OBJECT       *Op,
    887     UINT32                  CurrentByteOffset);
    888 
    889 ASL_RESOURCE_NODE *
    890 RsDoEndDependentDescriptor (
    891     ACPI_PARSE_OBJECT       *Op,
    892     UINT32                  CurrentByteOffset);
    893 
    894 ASL_RESOURCE_NODE *
    895 RsDoMemory24Descriptor (
    896     ACPI_PARSE_OBJECT       *Op,
    897     UINT32                  CurrentByteOffset);
    898 
    899 ASL_RESOURCE_NODE *
    900 RsDoMemory32Descriptor (
    901     ACPI_PARSE_OBJECT       *Op,
    902     UINT32                  CurrentByteOffset);
    903 
    904 ASL_RESOURCE_NODE *
    905 RsDoMemory32FixedDescriptor (
    906     ACPI_PARSE_OBJECT       *Op,
    907     UINT32                  CurrentByteOffset);
    908 
    909 ASL_RESOURCE_NODE *
    910 RsDoStartDependentDescriptor (
    911     ACPI_PARSE_OBJECT       *Op,
    912     UINT32                  CurrentByteOffset);
    913 
    914 ASL_RESOURCE_NODE *
    915 RsDoStartDependentNoPriDescriptor (
    916     ACPI_PARSE_OBJECT       *Op,
    917     UINT32                  CurrentByteOffset);
    918 
    919 ASL_RESOURCE_NODE *
    920 RsDoVendorSmallDescriptor (
    921     ACPI_PARSE_OBJECT       *Op,
    922     UINT32                  CurrentByteOffset);
    923 
    924 
    925 /*
    926  * aslrestype1i - I/O-related Small descriptors
    927  */
    928 ASL_RESOURCE_NODE *
    929 RsDoDmaDescriptor (
    930     ACPI_PARSE_OBJECT       *Op,
    931     UINT32                  CurrentByteOffset);
    932 
    933 ASL_RESOURCE_NODE *
    934 RsDoFixedIoDescriptor (
    935     ACPI_PARSE_OBJECT       *Op,
    936     UINT32                  CurrentByteOffset);
    937 
    938 ASL_RESOURCE_NODE *
    939 RsDoIoDescriptor (
    940     ACPI_PARSE_OBJECT       *Op,
    941     UINT32                  CurrentByteOffset);
    942 
    943 ASL_RESOURCE_NODE *
    944 RsDoIrqDescriptor (
    945     ACPI_PARSE_OBJECT       *Op,
    946     UINT32                  CurrentByteOffset);
    947 
    948 ASL_RESOURCE_NODE *
    949 RsDoIrqNoFlagsDescriptor (
    950     ACPI_PARSE_OBJECT       *Op,
    951     UINT32                  CurrentByteOffset);
    952 
    953 
    954 /*
    955  * aslrestype2 - Large resource descriptors
    956  */
    957 ASL_RESOURCE_NODE *
    958 RsDoInterruptDescriptor (
    959     ACPI_PARSE_OBJECT       *Op,
    960     UINT32                  CurrentByteOffset);
    961 
    962 ASL_RESOURCE_NODE *
    963 RsDoVendorLargeDescriptor (
    964     ACPI_PARSE_OBJECT       *Op,
    965     UINT32                  CurrentByteOffset);
    966 
    967 ASL_RESOURCE_NODE *
    968 RsDoGeneralRegisterDescriptor (
    969     ACPI_PARSE_OBJECT       *Op,
    970     UINT32                  CurrentByteOffset);
    971 
    972 
    973 /*
    974  * aslrestype2d - DWord address descriptors
    975  */
    976 ASL_RESOURCE_NODE *
    977 RsDoDwordIoDescriptor (
    978     ACPI_PARSE_OBJECT       *Op,
    979     UINT32                  CurrentByteOffset);
    980 
    981 ASL_RESOURCE_NODE *
    982 RsDoDwordMemoryDescriptor (
    983     ACPI_PARSE_OBJECT       *Op,
    984     UINT32                  CurrentByteOffset);
    985 
    986 ASL_RESOURCE_NODE *
    987 RsDoDwordSpaceDescriptor (
    988     ACPI_PARSE_OBJECT       *Op,
    989     UINT32                  CurrentByteOffset);
    990 
    991 
    992 /*
    993  * aslrestype2e - Extended address descriptors
    994  */
    995 ASL_RESOURCE_NODE *
    996 RsDoExtendedIoDescriptor (
    997     ACPI_PARSE_OBJECT       *Op,
    998     UINT32                  CurrentByteOffset);
    999 
   1000 ASL_RESOURCE_NODE *
   1001 RsDoExtendedMemoryDescriptor (
   1002     ACPI_PARSE_OBJECT       *Op,
   1003     UINT32                  CurrentByteOffset);
   1004 
   1005 ASL_RESOURCE_NODE *
   1006 RsDoExtendedSpaceDescriptor (
   1007     ACPI_PARSE_OBJECT       *Op,
   1008     UINT32                  CurrentByteOffset);
   1009 
   1010 
   1011 /*
   1012  * aslrestype2q - QWord address descriptors
   1013  */
   1014 ASL_RESOURCE_NODE *
   1015 RsDoQwordIoDescriptor (
   1016     ACPI_PARSE_OBJECT       *Op,
   1017     UINT32                  CurrentByteOffset);
   1018 
   1019 ASL_RESOURCE_NODE *
   1020 RsDoQwordMemoryDescriptor (
   1021     ACPI_PARSE_OBJECT       *Op,
   1022     UINT32                  CurrentByteOffset);
   1023 
   1024 ASL_RESOURCE_NODE *
   1025 RsDoQwordSpaceDescriptor (
   1026     ACPI_PARSE_OBJECT       *Op,
   1027     UINT32                  CurrentByteOffset);
   1028 
   1029 
   1030 /*
   1031  * aslrestype2w - Word address descriptors
   1032  */
   1033 ASL_RESOURCE_NODE *
   1034 RsDoWordIoDescriptor (
   1035     ACPI_PARSE_OBJECT       *Op,
   1036     UINT32                  CurrentByteOffset);
   1037 
   1038 ASL_RESOURCE_NODE *
   1039 RsDoWordSpaceDescriptor (
   1040     ACPI_PARSE_OBJECT       *Op,
   1041     UINT32                  CurrentByteOffset);
   1042 
   1043 ASL_RESOURCE_NODE *
   1044 RsDoWordBusNumberDescriptor (
   1045     ACPI_PARSE_OBJECT       *Op,
   1046     UINT32                  CurrentByteOffset);
   1047 
   1048 /*
   1049  * Entry to data table compiler subsystem
   1050  */
   1051 ACPI_STATUS
   1052 DtDoCompile(
   1053     void);
   1054 
   1055 ACPI_STATUS
   1056 DtCreateTemplates (
   1057     char                    *Signature);
   1058 
   1059 #endif /*  __ASLCOMPILER_H */
   1060 
   1061