Subversion Repositories Kolibri OS

Rev

Rev 1498 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

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