Home | History | Annotate | Line # | Download | only in compiler
aslcompiler.h revision 1.1.1.5.2.2 
      1 /******************************************************************************
      2  *
      3  * Module Name: aslcompiler.h - common include file for iASL
      4  *
      5  *****************************************************************************/
      6 
      7 /*
      8  * Copyright (C) 2000 - 2015, Intel Corp.
      9  * All rights reserved.
     10  *
     11  * Redistribution and use in source and binary forms, with or without
     12  * modification, are permitted provided that the following conditions
     13  * are met:
     14  * 1. Redistributions of source code must retain the above copyright
     15  *    notice, this list of conditions, and the following disclaimer,
     16  *    without modification.
     17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
     18  *    substantially similar to the "NO WARRANTY" disclaimer below
     19  *    ("Disclaimer") and any redistribution must be conditioned upon
     20  *    including a substantially similar Disclaimer requirement for further
     21  *    binary redistribution.
     22  * 3. Neither the names of the above-listed copyright holders nor the names
     23  *    of any contributors may be used to endorse or promote products derived
     24  *    from this software without specific prior written permission.
     25  *
     26  * Alternatively, this software may be distributed under the terms of the
     27  * GNU General Public License ("GPL") version 2 as published by the Free
     28  * Software Foundation.
     29  *
     30  * NO WARRANTY
     31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
     34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
     39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
     40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
     41  * POSSIBILITY OF SUCH DAMAGES.
     42  */
     43 
     44 #ifndef __ASLCOMPILER_H
     45 #define __ASLCOMPILER_H
     46 
     47 #include "acpi.h"
     48 #include "accommon.h"
     49 #include "amlresrc.h"
     50 #include "acdebug.h"
     51 
     52 /* Microsoft-specific */
     53 
     54 #if (defined WIN32 || defined WIN64)
     55 
     56 /* warn : used #pragma pack */
     57 #pragma warning(disable:4103)
     58 
     59 /* warn : named type definition in parentheses */
     60 #pragma warning(disable:4115)
     61 #endif
     62 
     63 #include <stdio.h>
     64 #include <stdlib.h>
     65 #include <stdarg.h>
     66 #include <string.h>
     67 #include <errno.h>
     68 #include <ctype.h>
     69 
     70 /* Compiler headers */
     71 
     72 #include "asldefine.h"
     73 #include "asltypes.h"
     74 #include "aslmessages.h"
     75 #include "aslglobal.h"
     76 #include "preprocess.h"
     77 
     78 
     79 /*******************************************************************************
     80  *
     81  * Compiler prototypes
     82  *
     83  ******************************************************************************/
     84 
     85 /*
     86  * Main ASL parser - generated from flex/bison, lex/yacc, etc.
     87  */
     88 ACPI_PARSE_OBJECT *
     89 AslDoError (
     90     void);
     91 
     92 int
     93 AslCompilerlex(
     94     void);
     95 
     96 void
     97 AslResetCurrentLineBuffer (
     98     void);
     99 
    100 void
    101 AslInsertLineBuffer (
    102     int                     SourceChar);
    103 
    104 int
    105 AslPopInputFileStack (
    106     void);
    107 
    108 void
    109 AslPushInputFileStack (
    110     FILE                    *InputFile,
    111     char                    *Filename);
    112 
    113 void
    114 AslParserCleanup (
    115     void);
    116 
    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 AslDoOneFile (
    131     char                    *Filename);
    132 
    133 ACPI_STATUS
    134 AslCheckForErrorExit (
    135     void);
    136 
    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 void
    162 CmDeleteCaches (
    163     void);
    164 
    165 
    166 /*
    167  * aslascii - ascii support
    168  */
    169 ACPI_STATUS
    170 FlCheckForAcpiTable (
    171     FILE                    *Handle);
    172 
    173 ACPI_STATUS
    174 FlCheckForAscii (
    175     char                    *Filename,
    176     BOOLEAN                 DisplayErrors);
    177 
    178 
    179 /*
    180  * aslwalks - semantic analysis and parse tree walks
    181  */
    182 ACPI_STATUS
    183 AnOtherSemanticAnalysisWalkBegin (
    184     ACPI_PARSE_OBJECT       *Op,
    185     UINT32                  Level,
    186     void                    *Context);
    187 
    188 ACPI_STATUS
    189 AnOtherSemanticAnalysisWalkEnd (
    190     ACPI_PARSE_OBJECT       *Op,
    191     UINT32                  Level,
    192     void                    *Context);
    193 
    194 ACPI_STATUS
    195 AnOperandTypecheckWalkEnd (
    196     ACPI_PARSE_OBJECT       *Op,
    197     UINT32                  Level,
    198     void                    *Context);
    199 
    200 ACPI_STATUS
    201 AnMethodTypingWalkEnd (
    202     ACPI_PARSE_OBJECT       *Op,
    203     UINT32                  Level,
    204     void                    *Context);
    205 
    206 
    207 /*
    208  * aslmethod - Control method analysis walk
    209  */
    210 ACPI_STATUS
    211 MtMethodAnalysisWalkBegin (
    212     ACPI_PARSE_OBJECT       *Op,
    213     UINT32                  Level,
    214     void                    *Context);
    215 
    216 ACPI_STATUS
    217 MtMethodAnalysisWalkEnd (
    218     ACPI_PARSE_OBJECT       *Op,
    219     UINT32                  Level,
    220     void                    *Context);
    221 
    222 
    223 /*
    224  * aslbtypes - bitfield data types
    225  */
    226 UINT32
    227 AnMapObjTypeToBtype (
    228     ACPI_PARSE_OBJECT       *Op);
    229 
    230 UINT32
    231 AnMapArgTypeToBtype (
    232     UINT32                  ArgType);
    233 
    234 UINT32
    235 AnGetBtype (
    236     ACPI_PARSE_OBJECT       *Op);
    237 
    238 void
    239 AnFormatBtype (
    240     char                    *Buffer,
    241     UINT32                  Btype);
    242 
    243 
    244 /*
    245  * aslanalyze - Support functions for parse tree walks
    246  */
    247 void
    248 AnCheckId (
    249     ACPI_PARSE_OBJECT       *Op,
    250     ACPI_NAME               Type);
    251 
    252 /* Values for Type argument above */
    253 
    254 #define ASL_TYPE_HID        0
    255 #define ASL_TYPE_CID        1
    256 
    257 BOOLEAN
    258 AnIsInternalMethod (
    259     ACPI_PARSE_OBJECT       *Op);
    260 
    261 UINT32
    262 AnGetInternalMethodReturnType (
    263     ACPI_PARSE_OBJECT       *Op);
    264 
    265 BOOLEAN
    266 AnLastStatementIsReturn (
    267     ACPI_PARSE_OBJECT       *Op);
    268 
    269 void
    270 AnCheckMethodReturnValue (
    271     ACPI_PARSE_OBJECT       *Op,
    272     const ACPI_OPCODE_INFO  *OpInfo,
    273     ACPI_PARSE_OBJECT       *ArgOp,
    274     UINT32                  RequiredBtypes,
    275     UINT32                  ThisNodeBtype);
    276 
    277 BOOLEAN
    278 AnIsResultUsed (
    279     ACPI_PARSE_OBJECT       *Op);
    280 
    281 void
    282 ApCheckForGpeNameConflict (
    283     ACPI_PARSE_OBJECT       *Op);
    284 
    285 void
    286 ApCheckRegMethod (
    287     ACPI_PARSE_OBJECT       *Op);
    288 
    289 BOOLEAN
    290 ApFindNameInScope (
    291     char                    *Name,
    292     ACPI_PARSE_OBJECT       *Op);
    293 
    294 
    295 /*
    296  * aslerror - error handling/reporting
    297  */
    298 void
    299 AslAbort (
    300     void);
    301 
    302 void
    303 AslError (
    304     UINT8                   Level,
    305     UINT16                  MessageId,
    306     ACPI_PARSE_OBJECT       *Op,
    307     char                    *ExtraMessage);
    308 
    309 ACPI_STATUS
    310 AslDisableException (
    311     char                    *MessageIdString);
    312 
    313 BOOLEAN
    314 AslIsExceptionDisabled (
    315     UINT8                   Level,
    316     UINT16                  MessageId);
    317 
    318 void
    319 AslCoreSubsystemError (
    320     ACPI_PARSE_OBJECT       *Op,
    321     ACPI_STATUS             Status,
    322     char                    *ExtraMessage,
    323     BOOLEAN                 Abort);
    324 
    325 int
    326 AslCompilererror(
    327     const char              *s);
    328 
    329 void
    330 AslCommonError (
    331     UINT8                   Level,
    332     UINT16                  MessageId,
    333     UINT32                  CurrentLineNumber,
    334     UINT32                  LogicalLineNumber,
    335     UINT32                  LogicalByteOffset,
    336     UINT32                  Column,
    337     char                    *Filename,
    338     char                    *ExtraMessage);
    339 
    340 void
    341 AslCommonError2 (
    342     UINT8                   Level,
    343     UINT16                  MessageId,
    344     UINT32                  LineNumber,
    345     UINT32                  Column,
    346     char                    *SourceLine,
    347     char                    *Filename,
    348     char                    *ExtraMessage);
    349 
    350 void
    351 AePrintException (
    352     UINT32                  FileId,
    353     ASL_ERROR_MSG           *Enode,
    354     char                    *Header);
    355 
    356 void
    357 AePrintErrorLog (
    358     UINT32                  FileId);
    359 
    360 void
    361 AeClearErrorLog (
    362     void);
    363 
    364 
    365 /*
    366  * asllisting - generate all "listing" type files
    367  */
    368 void
    369 LsDoListings (
    370     void);
    371 
    372 void
    373 LsWriteNodeToAsmListing (
    374     ACPI_PARSE_OBJECT       *Op);
    375 
    376 void
    377 LsWriteNode (
    378     ACPI_PARSE_OBJECT       *Op,
    379     UINT32                  FileId);
    380 
    381 void
    382 LsDumpParseTree (
    383     void);
    384 
    385 
    386 /*
    387  * asllistsup - Listing file support utilities
    388  */
    389 void
    390 LsDumpAscii (
    391     UINT32                  FileId,
    392     UINT32                  Count,
    393     UINT8                   *Buffer);
    394 
    395 void
    396 LsDumpAsciiInComment (
    397     UINT32                  FileId,
    398     UINT32                  Count,
    399     UINT8                   *Buffer);
    400 
    401 void
    402 LsCheckException (
    403     UINT32                  LineNumber,
    404     UINT32                  FileId);
    405 
    406 void
    407 LsFlushListingBuffer (
    408     UINT32                  FileId);
    409 
    410 void
    411 LsWriteListingHexBytes (
    412     UINT8                   *Buffer,
    413     UINT32                  Length,
    414     UINT32                  FileId);
    415 
    416 void
    417 LsWriteSourceLines (
    418     UINT32                  ToLineNumber,
    419     UINT32                  ToLogicalLineNumber,
    420     UINT32                  FileId);
    421 
    422 UINT32
    423 LsWriteOneSourceLine (
    424     UINT32                  FileId);
    425 
    426 void
    427 LsPushNode (
    428     char                    *Filename);
    429 
    430 ASL_LISTING_NODE *
    431 LsPopNode (
    432     void);
    433 
    434 
    435 /*
    436  * aslhex - generate all "hex" output files (C, ASM, ASL)
    437  */
    438 void
    439 HxDoHexOutput (
    440     void);
    441 
    442 
    443 /*
    444  * aslfold - constant folding
    445  */
    446 ACPI_STATUS
    447 OpcAmlConstantWalk (
    448     ACPI_PARSE_OBJECT       *Op,
    449     UINT32                  Level,
    450     void                    *Context);
    451 
    452 
    453 /*
    454  * aslmessages - exception strings
    455  */
    456 const char *
    457 AeDecodeMessageId (
    458     UINT16                  MessageId);
    459 
    460 const char *
    461 AeDecodeExceptionLevel (
    462     UINT8                   Level);
    463 
    464 UINT16
    465 AeBuildFullExceptionCode (
    466     UINT8                   Level,
    467     UINT16                  MessageId);
    468 
    469 /*
    470  * asloffset - generate C offset file for BIOS support
    471  */
    472 ACPI_STATUS
    473 LsAmlOffsetWalk (
    474     ACPI_PARSE_OBJECT       *Op,
    475     UINT32                  Level,
    476     void                    *Context);
    477 
    478 void
    479 LsDoOffsetTableHeader (
    480     UINT32                  FileId);
    481 
    482 void
    483 LsDoOffsetTableFooter (
    484     UINT32                  FileId);
    485 
    486 
    487 /*
    488  * aslopcodes - generate AML opcodes
    489  */
    490 ACPI_STATUS
    491 OpcAmlOpcodeWalk (
    492     ACPI_PARSE_OBJECT       *Op,
    493     UINT32                  Level,
    494     void                    *Context);
    495 
    496 ACPI_STATUS
    497 OpcAmlOpcodeUpdateWalk (
    498     ACPI_PARSE_OBJECT       *Op,
    499     UINT32                  Level,
    500     void                    *Context);
    501 
    502 void
    503 OpcGenerateAmlOpcode (
    504     ACPI_PARSE_OBJECT       *Op);
    505 
    506 UINT32
    507 OpcSetOptimalIntegerSize (
    508     ACPI_PARSE_OBJECT       *Op);
    509 
    510 void
    511 OpcGetIntegerWidth (
    512     ACPI_PARSE_OBJECT       *Op);
    513 
    514 
    515 /*
    516  * asloperands - generate AML operands for the AML opcodes
    517  */
    518 ACPI_PARSE_OBJECT  *
    519 UtGetArg (
    520     ACPI_PARSE_OBJECT       *Op,
    521     UINT32                  Argn);
    522 
    523 void
    524 OpnGenerateAmlOperands (
    525     ACPI_PARSE_OBJECT       *Op);
    526 
    527 void
    528 OpnDoPackage (
    529     ACPI_PARSE_OBJECT       *Op);
    530 
    531 
    532 /*
    533  * aslopt - optmization
    534  */
    535 void
    536 OptOptimizeNamePath (
    537     ACPI_PARSE_OBJECT       *Op,
    538     UINT32                  Flags,
    539     ACPI_WALK_STATE         *WalkState,
    540     char                    *AmlNameString,
    541     ACPI_NAMESPACE_NODE     *TargetNode);
    542 
    543 
    544 /*
    545  * aslprintf - Printf/Fprintf macros
    546  */
    547 void
    548 OpcDoPrintf (
    549     ACPI_PARSE_OBJECT       *Op);
    550 
    551 void
    552 OpcDoFprintf (
    553     ACPI_PARSE_OBJECT       *Op);
    554 
    555 
    556 /*
    557  * aslprune - parse tree pruner
    558  */
    559 void
    560 AslPruneParseTree (
    561     UINT32                  PruneDepth,
    562     UINT32                  Type);
    563 
    564 
    565 /*
    566  * aslcodegen - code generation
    567  */
    568 void
    569 CgGenerateAmlOutput (
    570     void);
    571 
    572 
    573 /*
    574  * aslfile
    575  */
    576 void
    577 FlOpenFile (
    578     UINT32                  FileId,
    579     char                    *Filename,
    580     char                    *Mode);
    581 
    582 
    583 /*
    584  * asllength - calculate/adjust AML package lengths
    585  */
    586 ACPI_STATUS
    587 LnPackageLengthWalk (
    588     ACPI_PARSE_OBJECT       *Op,
    589     UINT32                  Level,
    590     void                    *Context);
    591 
    592 ACPI_STATUS
    593 LnInitLengthsWalk (
    594     ACPI_PARSE_OBJECT       *Op,
    595     UINT32                  Level,
    596     void                    *Context);
    597 
    598 void
    599 CgGenerateAmlLengths (
    600     ACPI_PARSE_OBJECT       *Op);
    601 
    602 
    603 /*
    604  * aslmap - opcode mappings and reserved method names
    605  */
    606 ACPI_OBJECT_TYPE
    607 AslMapNamedOpcodeToDataType (
    608     UINT16                  Opcode);
    609 
    610 
    611 /*
    612  * aslpredef - ACPI predefined names support
    613  */
    614 BOOLEAN
    615 ApCheckForPredefinedMethod (
    616     ACPI_PARSE_OBJECT       *Op,
    617     ASL_METHOD_INFO         *MethodInfo);
    618 
    619 void
    620 ApCheckPredefinedReturnValue (
    621     ACPI_PARSE_OBJECT       *Op,
    622     ASL_METHOD_INFO         *MethodInfo);
    623 
    624 UINT32
    625 ApCheckForPredefinedName (
    626     ACPI_PARSE_OBJECT       *Op,
    627     char                    *Name);
    628 
    629 void
    630 ApCheckForPredefinedObject (
    631     ACPI_PARSE_OBJECT       *Op,
    632     char                    *Name);
    633 
    634 ACPI_STATUS
    635 ApCheckObjectType (
    636     const char              *PredefinedName,
    637     ACPI_PARSE_OBJECT       *Op,
    638     UINT32                  ExpectedBtypes,
    639     UINT32                  PackageIndex);
    640 
    641 void
    642 ApDisplayReservedNames (
    643     void);
    644 
    645 
    646 /*
    647  * aslprepkg - ACPI predefined names support for packages
    648  */
    649 void
    650 ApCheckPackage (
    651     ACPI_PARSE_OBJECT           *ParentOp,
    652     const ACPI_PREDEFINED_INFO  *Predefined);
    653 
    654 
    655 /*
    656  * asltransform - parse tree transformations
    657  */
    658 ACPI_STATUS
    659 TrAmlTransformWalk (
    660     ACPI_PARSE_OBJECT       *Op,
    661     UINT32                  Level,
    662     void                    *Context);
    663 
    664 
    665 /*
    666  * asltree - parse tree support
    667  */
    668 ACPI_STATUS
    669 TrWalkParseTree (
    670     ACPI_PARSE_OBJECT       *Op,
    671     UINT32                  Visitation,
    672     ASL_WALK_CALLBACK       DescendingCallback,
    673     ASL_WALK_CALLBACK       AscendingCallback,
    674     void                    *Context);
    675 
    676 /* Values for "Visitation" parameter above */
    677 
    678 #define ASL_WALK_VISIT_DOWNWARD     0x01
    679 #define ASL_WALK_VISIT_UPWARD       0x02
    680 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
    681 
    682 
    683 ACPI_PARSE_OBJECT *
    684 TrAllocateNode (
    685     UINT32                  ParseOpcode);
    686 
    687 void
    688 TrPrintNodeCompileFlags (
    689     UINT32                  Flags);
    690 
    691 void
    692 TrReleaseNode (
    693     ACPI_PARSE_OBJECT       *Op);
    694 
    695 ACPI_PARSE_OBJECT *
    696 TrUpdateNode (
    697     UINT32                  ParseOpcode,
    698     ACPI_PARSE_OBJECT       *Op);
    699 
    700 ACPI_PARSE_OBJECT *
    701 TrCreateNode (
    702     UINT32                  ParseOpcode,
    703     UINT32                  NumChildren,
    704     ...);
    705 
    706 ACPI_PARSE_OBJECT *
    707 TrCreateLeafNode (
    708     UINT32                  ParseOpcode);
    709 
    710 ACPI_PARSE_OBJECT *
    711 TrCreateNullTarget (
    712     void);
    713 
    714 ACPI_PARSE_OBJECT *
    715 TrCreateAssignmentNode (
    716     ACPI_PARSE_OBJECT       *Target,
    717     ACPI_PARSE_OBJECT       *Source);
    718 
    719 ACPI_PARSE_OBJECT *
    720 TrCreateTargetOperand (
    721     ACPI_PARSE_OBJECT       *OriginalOp,
    722     ACPI_PARSE_OBJECT       *ParentOp);
    723 
    724 ACPI_PARSE_OBJECT *
    725 TrCreateValuedLeafNode (
    726     UINT32                  ParseOpcode,
    727     UINT64                  Value);
    728 
    729 ACPI_PARSE_OBJECT *
    730 TrCreateConstantLeafNode (
    731     UINT32                  ParseOpcode);
    732 
    733 ACPI_PARSE_OBJECT *
    734 TrLinkChildren (
    735     ACPI_PARSE_OBJECT       *Op,
    736     UINT32                  NumChildren,
    737     ...);
    738 
    739 void
    740 TrSetEndLineNumber (
    741     ACPI_PARSE_OBJECT       *Op);
    742 
    743 void
    744 TrWalkTree (
    745     void);
    746 
    747 ACPI_PARSE_OBJECT *
    748 TrLinkPeerNode (
    749     ACPI_PARSE_OBJECT       *Op1,
    750     ACPI_PARSE_OBJECT       *Op2);
    751 
    752 ACPI_PARSE_OBJECT *
    753 TrLinkChildNode (
    754     ACPI_PARSE_OBJECT       *Op1,
    755     ACPI_PARSE_OBJECT       *Op2);
    756 
    757 ACPI_PARSE_OBJECT *
    758 TrSetNodeFlags (
    759     ACPI_PARSE_OBJECT       *Op,
    760     UINT32                  Flags);
    761 
    762 ACPI_PARSE_OBJECT *
    763 TrSetNodeAmlLength (
    764     ACPI_PARSE_OBJECT       *Op,
    765     UINT32                  Length);
    766 
    767 ACPI_PARSE_OBJECT *
    768 TrLinkPeerNodes (
    769     UINT32                  NumPeers,
    770     ...);
    771 
    772 
    773 /*
    774  * aslfiles - File I/O support
    775  */
    776 void
    777 FlAddIncludeDirectory (
    778     char                    *Dir);
    779 
    780 char *
    781 FlMergePathnames (
    782     char                    *PrefixDir,
    783     char                    *FilePathname);
    784 
    785 void
    786 FlOpenIncludeFile (
    787     ACPI_PARSE_OBJECT       *Op);
    788 
    789 void
    790 FlFileError (
    791     UINT32                  FileId,
    792     UINT8                   ErrorId);
    793 
    794 UINT32
    795 FlGetFileSize (
    796     UINT32                  FileId);
    797 
    798 ACPI_STATUS
    799 FlReadFile (
    800     UINT32                  FileId,
    801     void                    *Buffer,
    802     UINT32                  Length);
    803 
    804 void
    805 FlWriteFile (
    806     UINT32                  FileId,
    807     void                    *Buffer,
    808     UINT32                  Length);
    809 
    810 void
    811 FlSeekFile (
    812     UINT32                  FileId,
    813     long                    Offset);
    814 
    815 void
    816 FlCloseFile (
    817     UINT32                  FileId);
    818 
    819 void
    820 FlPrintFile (
    821     UINT32                  FileId,
    822     char                    *Format,
    823     ...);
    824 
    825 void
    826 FlDeleteFile (
    827     UINT32                  FileId);
    828 
    829 void
    830 FlSetLineNumber (
    831     UINT32                  LineNumber);
    832 
    833 void
    834 FlSetFilename (
    835     char                    *Filename);
    836 
    837 ACPI_STATUS
    838 FlOpenInputFile (
    839     char                    *InputFilename);
    840 
    841 ACPI_STATUS
    842 FlOpenAmlOutputFile (
    843     char                    *InputFilename);
    844 
    845 ACPI_STATUS
    846 FlOpenMiscOutputFiles (
    847     char                    *InputFilename);
    848 
    849 /*
    850  * aslhwmap - hardware map summary
    851  */
    852 void
    853 MpEmitMappingInfo (
    854     void);
    855 
    856 
    857 /*
    858  * asload - load namespace in prep for cross reference
    859  */
    860 ACPI_STATUS
    861 LdLoadNamespace (
    862     ACPI_PARSE_OBJECT       *RootOp);
    863 
    864 
    865 /*
    866  * asllookup - namespace lookup functions
    867  */
    868 void
    869 LkFindUnreferencedObjects (
    870     void);
    871 
    872 /*
    873  * aslmain - startup
    874  */
    875 void
    876 Usage (
    877     void);
    878 
    879 void
    880 AslFilenameHelp (
    881     void);
    882 
    883 
    884 /*
    885  * aslnamesp - namespace output file generation
    886  */
    887 ACPI_STATUS
    888 NsDisplayNamespace (
    889     void);
    890 
    891 void
    892 NsSetupNamespaceListing (
    893     void                    *Handle);
    894 
    895 /*
    896  * asloptions - command line processing
    897  */
    898 int
    899 AslCommandLine (
    900     int                     argc,
    901     char                    **argv);
    902 
    903 /*
    904  * aslxref - namespace cross reference
    905  */
    906 ACPI_STATUS
    907 XfCrossReferenceNamespace (
    908     void);
    909 
    910 
    911 /*
    912  * aslutils - common compiler utilites
    913  */
    914 void
    915 DbgPrint (
    916     UINT32                  Type,
    917     char                    *Format,
    918     ...);
    919 
    920 /* Type values for above */
    921 
    922 #define ASL_DEBUG_OUTPUT    0
    923 #define ASL_PARSE_OUTPUT    1
    924 #define ASL_TREE_OUTPUT     2
    925 
    926 void
    927 UtDisplaySupportedTables (
    928     void);
    929 
    930 void
    931 UtDisplayConstantOpcodes (
    932     void);
    933 
    934 UINT8
    935 UtBeginEvent (
    936     char                    *Name);
    937 
    938 void
    939 UtEndEvent (
    940     UINT8                   Event);
    941 
    942 void *
    943 UtLocalCalloc (
    944     UINT32                  Size);
    945 
    946 void
    947 UtLocalFree (
    948     void		    *Allocated,
    949     UINT32                  Size);
    950 
    951 void
    952 UtPrintFormattedName (
    953     UINT16                  ParseOpcode,
    954     UINT32                  Level);
    955 
    956 void
    957 UtDisplaySummary (
    958     UINT32                  FileId);
    959 
    960 void
    961 UtConvertByteToHex (
    962     UINT8                   RawByte,
    963     UINT8                   *Buffer);
    964 
    965 void
    966 UtConvertByteToAsmHex (
    967     UINT8                   RawByte,
    968     UINT8                   *Buffer);
    969 
    970 char *
    971 UtGetOpName (
    972     UINT32                  ParseOpcode);
    973 
    974 void
    975 UtSetParseOpName (
    976     ACPI_PARSE_OBJECT       *Op);
    977 
    978 char *
    979 UtStringCacheCalloc (
    980     UINT32                  Length);
    981 
    982 void
    983 UtExpandLineBuffers (
    984     void);
    985 
    986 void
    987 UtFreeLineBuffers (
    988     void);
    989 
    990 ACPI_STATUS
    991 UtInternalizeName (
    992     char                    *ExternalName,
    993     char                    **ConvertedName);
    994 
    995 void
    996 UtAttachNamepathToOwner (
    997     ACPI_PARSE_OBJECT       *Op,
    998     ACPI_PARSE_OBJECT       *NameNode);
    999 
   1000 ACPI_PARSE_OBJECT *
   1001 UtCheckIntegerRange (
   1002     ACPI_PARSE_OBJECT       *Op,
   1003     UINT32                  LowValue,
   1004     UINT32                  HighValue);
   1005 
   1006 UINT64
   1007 UtDoConstant (
   1008     char                    *String);
   1009 
   1010 ACPI_STATUS
   1011 stroul64 (
   1012     char                    *String,
   1013     UINT32                  Base,
   1014     UINT64                  *RetInteger);
   1015 
   1016 
   1017 /*
   1018  * asluuid - UUID support
   1019  */
   1020 ACPI_STATUS
   1021 AuValidateUuid (
   1022     char                    *InString);
   1023 
   1024 ACPI_STATUS
   1025 AuConvertUuidToString (
   1026     char                    *UuIdBuffer,
   1027     char                    *OutString);
   1028 
   1029 /*
   1030  * aslresource - Resource template generation utilities
   1031  */
   1032 void
   1033 RsSmallAddressCheck (
   1034     UINT8                   Type,
   1035     UINT32                  Minimum,
   1036     UINT32                  Maximum,
   1037     UINT32                  Length,
   1038     UINT32                  Alignment,
   1039     ACPI_PARSE_OBJECT       *MinOp,
   1040     ACPI_PARSE_OBJECT       *MaxOp,
   1041     ACPI_PARSE_OBJECT       *LengthOp,
   1042     ACPI_PARSE_OBJECT       *AlignOp,
   1043     ACPI_PARSE_OBJECT       *Op);
   1044 
   1045 void
   1046 RsLargeAddressCheck (
   1047     UINT64                  Minimum,
   1048     UINT64                  Maximum,
   1049     UINT64                  Length,
   1050     UINT64                  Granularity,
   1051     UINT8                   Flags,
   1052     ACPI_PARSE_OBJECT       *MinOp,
   1053     ACPI_PARSE_OBJECT       *MaxOp,
   1054     ACPI_PARSE_OBJECT       *LengthOp,
   1055     ACPI_PARSE_OBJECT       *GranOp,
   1056     ACPI_PARSE_OBJECT       *Op);
   1057 
   1058 UINT16
   1059 RsGetStringDataLength (
   1060     ACPI_PARSE_OBJECT       *InitializerOp);
   1061 
   1062 ASL_RESOURCE_NODE *
   1063 RsAllocateResourceNode (
   1064     UINT32                  Size);
   1065 
   1066 void
   1067 RsCreateResourceField (
   1068     ACPI_PARSE_OBJECT       *Op,
   1069     char                    *Name,
   1070     UINT32                  ByteOffset,
   1071     UINT32                  BitOffset,
   1072     UINT32                  BitLength);
   1073 
   1074 void
   1075 RsSetFlagBits (
   1076     UINT8                   *Flags,
   1077     ACPI_PARSE_OBJECT       *Op,
   1078     UINT8                   Position,
   1079     UINT8                   DefaultBit);
   1080 
   1081 void
   1082 RsSetFlagBits16 (
   1083     UINT16                  *Flags,
   1084     ACPI_PARSE_OBJECT       *Op,
   1085     UINT8                   Position,
   1086     UINT8                   DefaultBit);
   1087 
   1088 ACPI_PARSE_OBJECT *
   1089 RsCompleteNodeAndGetNext (
   1090     ACPI_PARSE_OBJECT       *Op);
   1091 
   1092 void
   1093 RsCheckListForDuplicates (
   1094     ACPI_PARSE_OBJECT       *Op);
   1095 
   1096 ASL_RESOURCE_NODE *
   1097 RsDoOneResourceDescriptor (
   1098     ASL_RESOURCE_INFO       *Info,
   1099     UINT8                   *State);
   1100 
   1101 /* Values for State above */
   1102 
   1103 #define ACPI_RSTATE_NORMAL              0
   1104 #define ACPI_RSTATE_START_DEPENDENT     1
   1105 #define ACPI_RSTATE_DEPENDENT_LIST      2
   1106 
   1107 UINT32
   1108 RsLinkDescriptorChain (
   1109     ASL_RESOURCE_NODE       **PreviousRnode,
   1110     ASL_RESOURCE_NODE       *Rnode);
   1111 
   1112 void
   1113 RsDoResourceTemplate (
   1114     ACPI_PARSE_OBJECT       *Op);
   1115 
   1116 
   1117 /*
   1118  * aslrestype1 - Miscellaneous Small descriptors
   1119  */
   1120 ASL_RESOURCE_NODE *
   1121 RsDoEndTagDescriptor (
   1122     ASL_RESOURCE_INFO       *Info);
   1123 
   1124 ASL_RESOURCE_NODE *
   1125 RsDoEndDependentDescriptor (
   1126     ASL_RESOURCE_INFO       *Info);
   1127 
   1128 ASL_RESOURCE_NODE *
   1129 RsDoMemory24Descriptor (
   1130     ASL_RESOURCE_INFO       *Info);
   1131 
   1132 ASL_RESOURCE_NODE *
   1133 RsDoMemory32Descriptor (
   1134     ASL_RESOURCE_INFO       *Info);
   1135 
   1136 ASL_RESOURCE_NODE *
   1137 RsDoMemory32FixedDescriptor (
   1138     ASL_RESOURCE_INFO       *Info);
   1139 
   1140 ASL_RESOURCE_NODE *
   1141 RsDoStartDependentDescriptor (
   1142     ASL_RESOURCE_INFO       *Info);
   1143 
   1144 ASL_RESOURCE_NODE *
   1145 RsDoStartDependentNoPriDescriptor (
   1146     ASL_RESOURCE_INFO       *Info);
   1147 
   1148 ASL_RESOURCE_NODE *
   1149 RsDoVendorSmallDescriptor (
   1150     ASL_RESOURCE_INFO       *Info);
   1151 
   1152 
   1153 /*
   1154  * aslrestype1i - I/O-related Small descriptors
   1155  */
   1156 ASL_RESOURCE_NODE *
   1157 RsDoDmaDescriptor (
   1158     ASL_RESOURCE_INFO       *Info);
   1159 
   1160 ASL_RESOURCE_NODE *
   1161 RsDoFixedDmaDescriptor (
   1162     ASL_RESOURCE_INFO       *Info);
   1163 
   1164 ASL_RESOURCE_NODE *
   1165 RsDoFixedIoDescriptor (
   1166     ASL_RESOURCE_INFO       *Info);
   1167 
   1168 ASL_RESOURCE_NODE *
   1169 RsDoIoDescriptor (
   1170     ASL_RESOURCE_INFO       *Info);
   1171 
   1172 ASL_RESOURCE_NODE *
   1173 RsDoIrqDescriptor (
   1174     ASL_RESOURCE_INFO       *Info);
   1175 
   1176 ASL_RESOURCE_NODE *
   1177 RsDoIrqNoFlagsDescriptor (
   1178     ASL_RESOURCE_INFO       *Info);
   1179 
   1180 
   1181 /*
   1182  * aslrestype2 - Large resource descriptors
   1183  */
   1184 ASL_RESOURCE_NODE *
   1185 RsDoInterruptDescriptor (
   1186     ASL_RESOURCE_INFO       *Info);
   1187 
   1188 ASL_RESOURCE_NODE *
   1189 RsDoVendorLargeDescriptor (
   1190     ASL_RESOURCE_INFO       *Info);
   1191 
   1192 ASL_RESOURCE_NODE *
   1193 RsDoGeneralRegisterDescriptor (
   1194     ASL_RESOURCE_INFO       *Info);
   1195 
   1196 ASL_RESOURCE_NODE *
   1197 RsDoGpioIntDescriptor (
   1198     ASL_RESOURCE_INFO       *Info);
   1199 
   1200 ASL_RESOURCE_NODE *
   1201 RsDoGpioIoDescriptor (
   1202     ASL_RESOURCE_INFO       *Info);
   1203 
   1204 ASL_RESOURCE_NODE *
   1205 RsDoI2cSerialBusDescriptor (
   1206     ASL_RESOURCE_INFO       *Info);
   1207 
   1208 ASL_RESOURCE_NODE *
   1209 RsDoSpiSerialBusDescriptor (
   1210     ASL_RESOURCE_INFO       *Info);
   1211 
   1212 ASL_RESOURCE_NODE *
   1213 RsDoUartSerialBusDescriptor (
   1214     ASL_RESOURCE_INFO       *Info);
   1215 
   1216 /*
   1217  * aslrestype2d - DWord address descriptors
   1218  */
   1219 ASL_RESOURCE_NODE *
   1220 RsDoDwordIoDescriptor (
   1221     ASL_RESOURCE_INFO       *Info);
   1222 
   1223 ASL_RESOURCE_NODE *
   1224 RsDoDwordMemoryDescriptor (
   1225     ASL_RESOURCE_INFO       *Info);
   1226 
   1227 ASL_RESOURCE_NODE *
   1228 RsDoDwordSpaceDescriptor (
   1229     ASL_RESOURCE_INFO       *Info);
   1230 
   1231 
   1232 /*
   1233  * aslrestype2e - Extended address descriptors
   1234  */
   1235 ASL_RESOURCE_NODE *
   1236 RsDoExtendedIoDescriptor (
   1237     ASL_RESOURCE_INFO       *Info);
   1238 
   1239 ASL_RESOURCE_NODE *
   1240 RsDoExtendedMemoryDescriptor (
   1241     ASL_RESOURCE_INFO       *Info);
   1242 
   1243 ASL_RESOURCE_NODE *
   1244 RsDoExtendedSpaceDescriptor (
   1245     ASL_RESOURCE_INFO       *Info);
   1246 
   1247 
   1248 /*
   1249  * aslrestype2q - QWord address descriptors
   1250  */
   1251 ASL_RESOURCE_NODE *
   1252 RsDoQwordIoDescriptor (
   1253     ASL_RESOURCE_INFO       *Info);
   1254 
   1255 ASL_RESOURCE_NODE *
   1256 RsDoQwordMemoryDescriptor (
   1257     ASL_RESOURCE_INFO       *Info);
   1258 
   1259 ASL_RESOURCE_NODE *
   1260 RsDoQwordSpaceDescriptor (
   1261     ASL_RESOURCE_INFO       *Info);
   1262 
   1263 
   1264 /*
   1265  * aslrestype2w - Word address descriptors
   1266  */
   1267 ASL_RESOURCE_NODE *
   1268 RsDoWordIoDescriptor (
   1269     ASL_RESOURCE_INFO       *Info);
   1270 
   1271 ASL_RESOURCE_NODE *
   1272 RsDoWordSpaceDescriptor (
   1273     ASL_RESOURCE_INFO       *Info);
   1274 
   1275 ASL_RESOURCE_NODE *
   1276 RsDoWordBusNumberDescriptor (
   1277     ASL_RESOURCE_INFO       *Info);
   1278 
   1279 
   1280 /*
   1281  * Entry to data table compiler subsystem
   1282  */
   1283 ACPI_STATUS
   1284 DtDoCompile(
   1285     void);
   1286 
   1287 ACPI_STATUS
   1288 DtCreateTemplates (
   1289     char                    *Signature);
   1290 
   1291 #endif /*  __ASLCOMPILER_H */
   1292