1 /******************************************************************************
2  *
3  * Module Name: aslcompiler.h - common include file for iASL
4  *
5  *****************************************************************************/
6 
7 /******************************************************************************
8  *
9  * 1. Copyright Notice
10  *
11  * Some or all of this work - Copyright (c) 1999 - 2021, Intel Corp.
12  * All rights reserved.
13  *
14  * 2. License
15  *
16  * 2.1. This is your license from Intel Corp. under its intellectual property
17  * rights. You may have additional license terms from the party that provided
18  * you this software, covering your right to use that party's intellectual
19  * property rights.
20  *
21  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
22  * copy of the source code appearing in this file ("Covered Code") an
23  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
24  * base code distributed originally by Intel ("Original Intel Code") to copy,
25  * make derivatives, distribute, use and display any portion of the Covered
26  * Code in any form, with the right to sublicense such rights; and
27  *
28  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
29  * license (with the right to sublicense), under only those claims of Intel
30  * patents that are infringed by the Original Intel Code, to make, use, sell,
31  * offer to sell, and import the Covered Code and derivative works thereof
32  * solely to the minimum extent necessary to exercise the above copyright
33  * license, and in no event shall the patent license extend to any additions
34  * to or modifications of the Original Intel Code. No other license or right
35  * is granted directly or by implication, estoppel or otherwise;
36  *
37  * The above copyright and patent license is granted only if the following
38  * conditions are met:
39  *
40  * 3. Conditions
41  *
42  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
43  * Redistribution of source code of any substantial portion of the Covered
44  * Code or modification with rights to further distribute source must include
45  * the above Copyright Notice, the above License, this list of Conditions,
46  * and the following Disclaimer and Export Compliance provision. In addition,
47  * Licensee must cause all Covered Code to which Licensee contributes to
48  * contain a file documenting the changes Licensee made to create that Covered
49  * Code and the date of any change. Licensee must include in that file the
50  * documentation of any changes made by any predecessor Licensee. Licensee
51  * must include a prominent statement that the modification is derived,
52  * directly or indirectly, from Original Intel Code.
53  *
54  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
55  * Redistribution of source code of any substantial portion of the Covered
56  * Code or modification without rights to further distribute source must
57  * include the following Disclaimer and Export Compliance provision in the
58  * documentation and/or other materials provided with distribution. In
59  * addition, Licensee may not authorize further sublicense of source of any
60  * portion of the Covered Code, and must include terms to the effect that the
61  * license from Licensee to its licensee is limited to the intellectual
62  * property embodied in the software Licensee provides to its licensee, and
63  * not to intellectual property embodied in modifications its licensee may
64  * make.
65  *
66  * 3.3. Redistribution of Executable. Redistribution in executable form of any
67  * substantial portion of the Covered Code or modification must reproduce the
68  * above Copyright Notice, and the following Disclaimer and Export Compliance
69  * provision in the documentation and/or other materials provided with the
70  * distribution.
71  *
72  * 3.4. Intel retains all right, title, and interest in and to the Original
73  * Intel Code.
74  *
75  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
76  * Intel shall be used in advertising or otherwise to promote the sale, use or
77  * other dealings in products derived from or relating to the Covered Code
78  * without prior written authorization from Intel.
79  *
80  * 4. Disclaimer and Export Compliance
81  *
82  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
83  * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
84  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
85  * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
86  * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
87  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
88  * PARTICULAR PURPOSE.
89  *
90  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
91  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
92  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
93  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
94  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
95  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
96  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
97  * LIMITED REMEDY.
98  *
99  * 4.3. Licensee shall not export, either directly or indirectly, any of this
100  * software or system incorporating such software without first obtaining any
101  * required license or other approval from the U. S. Department of Commerce or
102  * any other agency or department of the United States Government. In the
103  * event Licensee exports any such software from the United States or
104  * re-exports any such software from a foreign destination, Licensee shall
105  * ensure that the distribution and export/re-export of the software is in
106  * compliance with all laws, regulations, orders, or other restrictions of the
107  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
108  * any of its subsidiaries will export/re-export any technical data, process,
109  * software, or service, directly or indirectly, to any country for which the
110  * United States government or any agency thereof requires an export license,
111  * other governmental approval, or letter of assurance, without first obtaining
112  * such license, approval or letter.
113  *
114  *****************************************************************************
115  *
116  * Alternatively, you may choose to be licensed under the terms of the
117  * following license:
118  *
119  * Redistribution and use in source and binary forms, with or without
120  * modification, are permitted provided that the following conditions
121  * are met:
122  * 1. Redistributions of source code must retain the above copyright
123  *    notice, this list of conditions, and the following disclaimer,
124  *    without modification.
125  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
126  *    substantially similar to the "NO WARRANTY" disclaimer below
127  *    ("Disclaimer") and any redistribution must be conditioned upon
128  *    including a substantially similar Disclaimer requirement for further
129  *    binary redistribution.
130  * 3. Neither the names of the above-listed copyright holders nor the names
131  *    of any contributors may be used to endorse or promote products derived
132  *    from this software without specific prior written permission.
133  *
134  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
135  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
136  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
137  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
138  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
139  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
140  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
141  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
142  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
143  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
144  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
145  *
146  * Alternatively, you may choose to be licensed under the terms of the
147  * GNU General Public License ("GPL") version 2 as published by the Free
148  * Software Foundation.
149  *
150  *****************************************************************************/
151 
152 #ifndef __ASLCOMPILER_H
153 #define __ASLCOMPILER_H
154 
155 #include "acpi.h"
156 #include "accommon.h"
157 #include "amlresrc.h"
158 #include "acdebug.h"
159 
160 /* Microsoft-specific */
161 
162 #if (defined WIN32 || defined WIN64)
163 
164 /* warn : used #pragma pack */
165 #pragma warning(disable:4103)
166 
167 /* warn : named type definition in parentheses */
168 #pragma warning(disable:4115)
169 #endif
170 
171 #include <stdio.h>
172 #include <stdlib.h>
173 #include <string.h>
174 #include <errno.h>
175 #include <ctype.h>
176 
177 /* Compiler headers */
178 
179 #include "asldefine.h"
180 #include "asltypes.h"
181 #include "aslmessages.h"
182 #include "aslglobal.h"
183 #include "preprocess.h"
184 #include "dtcompiler.h"
185 
186 
187 /*******************************************************************************
188  *
189  * Compiler prototypes
190  *
191  ******************************************************************************/
192 
193 /*
194  * Main ASL parser - generated from flex/bison, lex/yacc, etc.
195  */
196 ACPI_PARSE_OBJECT *
197 AslDoError (
198     void);
199 
200 int
201 AslCompilerlex(
202     void);
203 
204 void
205 AslResetCurrentLineBuffer (
206     void);
207 
208 void
209 AslInsertLineBuffer (
210     int                     SourceChar);
211 
212 int
213 AslPopInputFileStack (
214     void);
215 
216 void
217 AslPushInputFileStack (
218     FILE                    *InputFile,
219     char                    *Filename);
220 
221 void
222 AslParserCleanup (
223     void);
224 
225 
226 /*
227  * aslstartup - entered from main()
228  */
229 void
230 AslInitializeGlobals (
231     void);
232 
233 typedef
234 ACPI_STATUS (*ASL_PATHNAME_CALLBACK) (
235     char *);
236 
237 ACPI_STATUS
238 AslDoOneFile (
239     char                    *Filename);
240 
241 ACPI_STATUS
242 AslCheckForErrorExit (
243     void);
244 
245 
246 /*
247  * aslcompile - compile mainline
248  */
249 void
250 AslCompilerSignon (
251     UINT32                  FileId);
252 
253 void
254 AslCompilerFileHeader (
255     UINT32                  FileId);
256 
257 ACPI_STATUS
258 CmDoCompile (
259     void);
260 
261 int
262 CmDoAslMiddleAndBackEnd (
263     void);
264 
265 void
266 CmDoOutputFiles (
267     void);
268 
269 int
270 CmCleanupAndExit (
271     void);
272 
273 ACPI_STATUS
274 AslDoDisassembly (
275     void);
276 
277 
278 /*
279  * aslallocate - memory allocation
280  */
281 void *
282 UtLocalCalloc (
283     UINT32                  Size);
284 
285 void
286 UtExpandLineBuffers (
287     void);
288 
289 void
290 UtReallocLineBuffers (
291     char                    **Buffer,
292     UINT32                  OldSize,
293     UINT32                  NewSize);
294 
295 void
296 UtFreeLineBuffers (
297     void);
298 
299 
300 /*
301  * aslcache - local cache support
302  */
303 char *
304 UtLocalCacheCalloc (
305     UINT32                  Length);
306 
307 ACPI_PARSE_OBJECT *
308 UtParseOpCacheCalloc (
309     void);
310 
311 DT_SUBTABLE *
312 UtSubtableCacheCalloc (
313     void);
314 
315 DT_FIELD *
316 UtFieldCacheCalloc (
317     void);
318 
319 void
320 UtDeleteLocalCaches (
321     void);
322 
323 
324 /*
325  * aslascii - ascii support
326  */
327 ACPI_STATUS
328 FlIsFileAsciiSource (
329     char                    *Filename,
330     BOOLEAN                 DisplayErrors);
331 
332 
333 /*
334  * aslwalks - semantic analysis and parse tree walks
335  */
336 ACPI_STATUS
337 AnOtherSemanticAnalysisWalkBegin (
338     ACPI_PARSE_OBJECT       *Op,
339     UINT32                  Level,
340     void                    *Context);
341 
342 ACPI_STATUS
343 AnOtherSemanticAnalysisWalkEnd (
344     ACPI_PARSE_OBJECT       *Op,
345     UINT32                  Level,
346     void                    *Context);
347 
348 ACPI_STATUS
349 AnOperandTypecheckWalkEnd (
350     ACPI_PARSE_OBJECT       *Op,
351     UINT32                  Level,
352     void                    *Context);
353 
354 ACPI_STATUS
355 AnMethodTypingWalkEnd (
356     ACPI_PARSE_OBJECT       *Op,
357     UINT32                  Level,
358     void                    *Context);
359 
360 
361 /*
362  * aslmethod - Control method analysis walk
363  */
364 ACPI_STATUS
365 MtMethodAnalysisWalkBegin (
366     ACPI_PARSE_OBJECT       *Op,
367     UINT32                  Level,
368     void                    *Context);
369 
370 ACPI_STATUS
371 MtMethodAnalysisWalkEnd (
372     ACPI_PARSE_OBJECT       *Op,
373     UINT32                  Level,
374     void                    *Context);
375 
376 UINT32
377 MtProcessTypeOp (
378     ACPI_PARSE_OBJECT       *TypeOp);
379 
380 UINT8
381 MtProcessParameterTypeList (
382     ACPI_PARSE_OBJECT       *ParamTypeOp,
383     UINT32                  *TypeList);
384 
385 
386 /*
387  * aslbtypes - bitfield data types
388  */
389 UINT32
390 AnMapObjTypeToBtype (
391     ACPI_PARSE_OBJECT       *Op);
392 
393 UINT32
394 AnMapArgTypeToBtype (
395     UINT32                  ArgType);
396 
397 UINT32
398 AnGetBtype (
399     ACPI_PARSE_OBJECT       *Op);
400 
401 void
402 AnFormatBtype (
403     char                    *Buffer,
404     UINT32                  Btype);
405 
406 
407 /*
408  * aslanalyze - Support functions for parse tree walks
409  */
410 void
411 AnCheckId (
412     ACPI_PARSE_OBJECT       *Op,
413     ACPI_NAME               Type);
414 
415 /* Values for Type argument above */
416 
417 #define ASL_TYPE_HID        0
418 #define ASL_TYPE_CID        1
419 
420 BOOLEAN
421 AnIsInternalMethod (
422     ACPI_PARSE_OBJECT       *Op);
423 
424 UINT32
425 AnGetInternalMethodReturnType (
426     ACPI_PARSE_OBJECT       *Op);
427 
428 BOOLEAN
429 AnLastStatementIsReturn (
430     ACPI_PARSE_OBJECT       *Op);
431 
432 void
433 AnCheckMethodReturnValue (
434     ACPI_PARSE_OBJECT       *Op,
435     const ACPI_OPCODE_INFO  *OpInfo,
436     ACPI_PARSE_OBJECT       *ArgOp,
437     UINT32                  RequiredBtypes,
438     UINT32                  ThisNodeBtype);
439 
440 BOOLEAN
441 AnIsResultUsed (
442     ACPI_PARSE_OBJECT       *Op);
443 
444 void
445 ApCheckForGpeNameConflict (
446     ACPI_PARSE_OBJECT       *Op);
447 
448 void
449 ApCheckRegMethod (
450     ACPI_PARSE_OBJECT       *Op);
451 
452 BOOLEAN
453 ApFindNameInScope (
454     char                    *Name,
455     ACPI_PARSE_OBJECT       *Op);
456 
457 BOOLEAN
458 ApFindNameInDeviceTree (
459     char                    *Name,
460     ACPI_PARSE_OBJECT       *Op);
461 
462 /*
463  * aslerror - error handling/reporting
464  */
465 void
466 AslAbort (
467     void);
468 
469 void
470 AslDualParseOpError (
471     UINT8                   Level,
472     UINT16                  MainMessageId,
473     ACPI_PARSE_OBJECT       *MainOp,
474     char                    *MainMessage,
475     UINT16                  SecondMessageId,
476     ACPI_PARSE_OBJECT       *SecondOp,
477     char                    *SecondaryMessage);
478 
479 void
480 AslError (
481     UINT8                   Level,
482     UINT16                  MessageId,
483     ACPI_PARSE_OBJECT       *Op,
484     char                    *ExtraMessage);
485 
486 void
487 AslCheckExpectedExceptions (
488     void);
489 
490 ACPI_STATUS
491 AslLogExpectedException (
492     char                    *MessageIdString);
493 
494 ACPI_STATUS
495 AslElevateException (
496     char                    *MessageIdString);
497 
498 ACPI_STATUS
499 AslDisableException (
500     char                    *MessageIdString);
501 
502 BOOLEAN
503 AslIsExceptionIgnored (
504     char                    *Filename,
505     UINT32                  LineNumber,
506     UINT8                   Level,
507     UINT16                  MessageId);
508 
509 void
510 AslLogExpectedExceptionByLine (
511     char                    *MessageIdString);
512 
513 void
514 AslCoreSubsystemError (
515     ACPI_PARSE_OBJECT       *Op,
516     ACPI_STATUS             Status,
517     char                    *ExtraMessage,
518     BOOLEAN                 Abort);
519 
520 int
521 AslCompilererror(
522     const char              *s);
523 
524 void
525 AslCommonError (
526     UINT8                   Level,
527     UINT16                  MessageId,
528     UINT32                  CurrentLineNumber,
529     UINT32                  LogicalLineNumber,
530     UINT32                  LogicalByteOffset,
531     UINT32                  Column,
532     char                    *Filename,
533     char                    *ExtraMessage);
534 
535 void
536 AslCommonError2 (
537     UINT8                   Level,
538     UINT16                  MessageId,
539     UINT32                  LineNumber,
540     UINT32                  Column,
541     char                    *SourceLine,
542     char                    *Filename,
543     char                    *ExtraMessage);
544 
545 void
546 AePrintException (
547     UINT32                  FileId,
548     ASL_ERROR_MSG           *Enode,
549     char                    *Header);
550 
551 void
552 AePrintErrorLog (
553     UINT32                  FileId);
554 
555 void
556 AeClearErrorLog (
557     void);
558 
559 
560 /*
561  * asllisting - generate all "listing" type files
562  */
563 void
564 LsDoListings (
565     void);
566 
567 void
568 LsWriteNodeToAsmListing (
569     ACPI_PARSE_OBJECT       *Op);
570 
571 void
572 LsWriteNode (
573     ACPI_PARSE_OBJECT       *Op,
574     UINT32                  FileId);
575 
576 void
577 LsDumpParseTree (
578     void);
579 
580 
581 /*
582  * asllistsup - Listing file support utilities
583  */
584 void
585 LsDumpAscii (
586     UINT32                  FileId,
587     UINT32                  Count,
588     UINT8                   *Buffer);
589 
590 void
591 LsDumpAsciiInComment (
592     UINT32                  FileId,
593     UINT32                  Count,
594     UINT8                   *Buffer);
595 
596 void
597 LsCheckException (
598     UINT32                  LineNumber,
599     UINT32                  FileId);
600 
601 void
602 LsFlushListingBuffer (
603     UINT32                  FileId);
604 
605 void
606 LsWriteListingHexBytes (
607     UINT8                   *Buffer,
608     UINT32                  Length,
609     UINT32                  FileId);
610 
611 void
612 LsWriteSourceLines (
613     UINT32                  ToLineNumber,
614     UINT32                  ToLogicalLineNumber,
615     UINT32                  FileId);
616 
617 UINT32
618 LsWriteOneSourceLine (
619     UINT32                  FileId);
620 
621 void
622 LsPushNode (
623     char                    *Filename);
624 
625 ASL_LISTING_NODE *
626 LsPopNode (
627     void);
628 
629 
630 /*
631  * aslhex - generate all "hex" output files (C, ASM, ASL)
632  */
633 void
634 HxDoHexOutput (
635     void);
636 
637 
638 /*
639  * aslfold - constant folding
640  */
641 ACPI_STATUS
642 OpcAmlConstantWalk (
643     ACPI_PARSE_OBJECT       *Op,
644     UINT32                  Level,
645     void                    *Context);
646 
647 
648 /*
649  * aslmessages - exception strings
650  */
651 const char *
652 AeDecodeMessageId (
653     UINT16                  MessageId);
654 
655 const char *
656 AeDecodeExceptionLevel (
657     UINT8                   Level);
658 
659 UINT16
660 AeBuildFullExceptionCode (
661     UINT8                   Level,
662     UINT16                  MessageId);
663 
664 /*
665  * asloffset - generate C offset file for BIOS support
666  */
667 ACPI_STATUS
668 LsAmlOffsetWalk (
669     ACPI_PARSE_OBJECT       *Op,
670     UINT32                  Level,
671     void                    *Context);
672 
673 void
674 LsDoOffsetTableHeader (
675     UINT32                  FileId);
676 
677 void
678 LsDoOffsetTableFooter (
679     UINT32                  FileId);
680 
681 
682 /*
683  * aslopcodes - generate AML opcodes
684  */
685 ACPI_STATUS
686 OpcAmlOpcodeWalk (
687     ACPI_PARSE_OBJECT       *Op,
688     UINT32                  Level,
689     void                    *Context);
690 
691 ACPI_STATUS
692 OpcAmlOpcodeUpdateWalk (
693     ACPI_PARSE_OBJECT       *Op,
694     UINT32                  Level,
695     void                    *Context);
696 
697 void
698 OpcGenerateAmlOpcode (
699     ACPI_PARSE_OBJECT       *Op);
700 
701 UINT32
702 OpcSetOptimalIntegerSize (
703     ACPI_PARSE_OBJECT       *Op);
704 
705 void
706 OpcGetIntegerWidth (
707     ACPI_PARSE_OBJECT       *Op);
708 
709 
710 /*
711  * asloperands - generate AML operands for the AML opcodes
712  */
713 ACPI_PARSE_OBJECT  *
714 UtGetArg (
715     ACPI_PARSE_OBJECT       *Op,
716     UINT32                  Argn);
717 
718 void
719 OpnGenerateAmlOperands (
720     ACPI_PARSE_OBJECT       *Op);
721 
722 void
723 OpnDoPackage (
724     ACPI_PARSE_OBJECT       *Op);
725 
726 
727 /*
728  * aslopt - optimization
729  */
730 void
731 OptOptimizeNamePath (
732     ACPI_PARSE_OBJECT       *Op,
733     UINT32                  Flags,
734     ACPI_WALK_STATE         *WalkState,
735     char                    *AmlNameString,
736     ACPI_NAMESPACE_NODE     *TargetNode);
737 
738 
739 /*
740  * aslpld - ToPLD macro support
741  */
742 void
743 OpcDoPld (
744     ACPI_PARSE_OBJECT       *Op);
745 
746 
747 /*
748  * aslprintf - Printf/Fprintf macros
749  */
750 void
751 OpcDoPrintf (
752     ACPI_PARSE_OBJECT       *Op);
753 
754 void
755 OpcDoFprintf (
756     ACPI_PARSE_OBJECT       *Op);
757 
758 
759 /*
760  * aslprune - parse tree pruner
761  */
762 void
763 AslPruneParseTree (
764     UINT32                  PruneDepth,
765     UINT32                  Type);
766 
767 
768 /*
769  * aslcodegen - code generation
770  */
771 void
772 CgGenerateAmlOutput (
773     void);
774 
775 void
776 CgLocalWriteAmlData (
777     ACPI_PARSE_OBJECT       *Op,
778     void                    *Buffer,
779     UINT32                  Length);
780 
781 
782 /*
783  * aslfile
784  */
785 void
786 FlOpenFile (
787     UINT32                  FileId,
788     char                    *Filename,
789     char                    *Mode);
790 
791 
792 /*
793  * asllength - calculate/adjust AML package lengths
794  */
795 ACPI_STATUS
796 LnPackageLengthWalk (
797     ACPI_PARSE_OBJECT       *Op,
798     UINT32                  Level,
799     void                    *Context);
800 
801 ACPI_STATUS
802 LnInitLengthsWalk (
803     ACPI_PARSE_OBJECT       *Op,
804     UINT32                  Level,
805     void                    *Context);
806 
807 void
808 CgGenerateAmlLengths (
809     ACPI_PARSE_OBJECT       *Op);
810 
811 
812 /*
813  * aslmap - opcode mappings and reserved method names
814  */
815 ACPI_OBJECT_TYPE
816 AslMapNamedOpcodeToDataType (
817     UINT16                  Opcode);
818 
819 
820 /*
821  * aslpredef - ACPI predefined names support
822  */
823 BOOLEAN
824 ApCheckForPredefinedMethod (
825     ACPI_PARSE_OBJECT       *Op,
826     ASL_METHOD_INFO         *MethodInfo);
827 
828 void
829 ApCheckPredefinedReturnValue (
830     ACPI_PARSE_OBJECT       *Op,
831     ASL_METHOD_INFO         *MethodInfo);
832 
833 UINT32
834 ApCheckForPredefinedName (
835     ACPI_PARSE_OBJECT       *Op,
836     char                    *Name);
837 
838 void
839 ApCheckForPredefinedObject (
840     ACPI_PARSE_OBJECT       *Op,
841     char                    *Name);
842 
843 ACPI_STATUS
844 ApCheckObjectType (
845     const char              *PredefinedName,
846     ACPI_PARSE_OBJECT       *Op,
847     UINT32                  ExpectedBtypes,
848     UINT32                  PackageIndex);
849 
850 void
851 ApDisplayReservedNames (
852     void);
853 
854 
855 /*
856  * aslprepkg - ACPI predefined names support for packages
857  */
858 void
859 ApCheckPackage (
860     ACPI_PARSE_OBJECT           *ParentOp,
861     const ACPI_PREDEFINED_INFO  *Predefined);
862 
863 
864 /*
865  * asltransform - parse tree transformations
866  */
867 ACPI_STATUS
868 TrAmlTransformWalkBegin (
869     ACPI_PARSE_OBJECT       *Op,
870     UINT32                  Level,
871     void                    *Context);
872 
873 ACPI_STATUS
874 TrAmlTransformWalkEnd (
875     ACPI_PARSE_OBJECT       *Op,
876     UINT32                  Level,
877     void                    *Context);
878 
879 
880 /*
881  * aslexternal - External opcode support
882  */
883 ACPI_STATUS
884 ExAmlExternalWalkBegin (
885     ACPI_PARSE_OBJECT       *Op,
886     UINT32                  Level,
887     void                    *Context);
888 
889 ACPI_STATUS
890 ExAmlExternalWalkEnd (
891     ACPI_PARSE_OBJECT       *Op,
892     UINT32                  Level,
893     void                    *Context);
894 
895 void
896 ExDoExternal (
897     ACPI_PARSE_OBJECT       *Op);
898 
899 /* Values for "Visitation" parameter above */
900 
901 #define ASL_WALK_VISIT_DOWNWARD         0x01
902 #define ASL_WALK_VISIT_UPWARD           0x02
903 #define ASL_WALK_VISIT_DB_SEPARATELY    0x04
904 #define ASL_WALK_VISIT_TWICE            (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
905 
906 
907 /*
908  * aslparseop.c - Parse op create/allocate/cache
909  */
910 ACPI_PARSE_OBJECT *
911 TrCreateOp (
912     UINT32                  ParseOpcode,
913     UINT32                  NumChildren,
914     ...);
915 
916 ACPI_PARSE_OBJECT *
917 TrCreateLeafOp (
918     UINT32                  ParseOpcode);
919 
920 ACPI_PARSE_OBJECT *
921 TrCreateNullTargetOp (
922     void);
923 
924 ACPI_PARSE_OBJECT *
925 TrCreateAssignmentOp (
926     ACPI_PARSE_OBJECT       *Target,
927     ACPI_PARSE_OBJECT       *Source);
928 
929 ACPI_PARSE_OBJECT *
930 TrCreateTargetOp (
931     ACPI_PARSE_OBJECT       *OriginalOp,
932     ACPI_PARSE_OBJECT       *ParentOp);
933 
934 ACPI_PARSE_OBJECT *
935 TrCreateValuedLeafOp (
936     UINT32                  ParseOpcode,
937     UINT64                  Value);
938 
939 ACPI_PARSE_OBJECT *
940 TrCreateConstantLeafOp (
941     UINT32                  ParseOpcode);
942 
943 ACPI_PARSE_OBJECT *
944 TrAllocateOp (
945     UINT32                  ParseOpcode);
946 
947 void
948 TrPrintOpFlags (
949     UINT32                  Flags,
950     UINT32                  OutputLevel);
951 
952 
953 /*
954  * asltree.c - Parse tree management
955  */
956 void
957 TrSetOpParent (
958     ACPI_PARSE_OBJECT       *Op,
959     ACPI_PARSE_OBJECT       *ParentOp);
960 
961 ACPI_PARSE_OBJECT *
962 TrSetOpIntegerValue (
963     UINT32                  ParseOpcode,
964     ACPI_PARSE_OBJECT       *Op);
965 
966 void
967 TrSetOpEndLineNumber (
968     ACPI_PARSE_OBJECT       *Op);
969 
970 void
971 TrSetOpCurrentFilename (
972     ACPI_PARSE_OBJECT       *Op);
973 
974 void
975 TrSetOpIntegerWidth (
976     ACPI_PARSE_OBJECT       *TableSignature,
977     ACPI_PARSE_OBJECT       *Revision);
978 
979 ACPI_PARSE_OBJECT *
980 TrLinkOpChildren (
981     ACPI_PARSE_OBJECT       *Op,
982     UINT32                  NumChildren,
983     ...);
984 
985 ACPI_PARSE_OBJECT *
986 TrLinkPeerOp (
987     ACPI_PARSE_OBJECT       *Op1,
988     ACPI_PARSE_OBJECT       *Op2);
989 
990 ACPI_PARSE_OBJECT *
991 TrLinkChildOp (
992     ACPI_PARSE_OBJECT       *Op1,
993     ACPI_PARSE_OBJECT       *Op2);
994 
995 ACPI_PARSE_OBJECT *
996 TrSetOpFlags (
997     ACPI_PARSE_OBJECT       *Op,
998     UINT32                  Flags);
999 
1000 ACPI_PARSE_OBJECT *
1001 TrSetOpAmlLength (
1002     ACPI_PARSE_OBJECT       *Op,
1003     UINT32                  Length);
1004 
1005 ACPI_PARSE_OBJECT *
1006 TrLinkPeerOps (
1007     UINT32                  NumPeers,
1008     ...);
1009 
1010 ACPI_STATUS
1011 TrWalkParseTree (
1012     ACPI_PARSE_OBJECT       *Op,
1013     UINT32                  Visitation,
1014     ASL_WALK_CALLBACK       DescendingCallback,
1015     ASL_WALK_CALLBACK       AscendingCallback,
1016     void                    *Context);
1017 
1018 
1019 /*
1020  * aslfiles - File I/O support
1021  */
1022 void
1023 FlAddIncludeDirectory (
1024     char                    *Dir);
1025 
1026 char *
1027 FlMergePathnames (
1028     char                    *PrefixDir,
1029     char                    *FilePathname);
1030 
1031 void
1032 FlOpenIncludeFile (
1033     ACPI_PARSE_OBJECT       *Op);
1034 
1035 void
1036 FlFileError (
1037     UINT32                  FileId,
1038     UINT8                   ErrorId);
1039 
1040 UINT32
1041 FlGetFileSize (
1042     UINT32                  FileId);
1043 
1044 ACPI_STATUS
1045 FlReadFile (
1046     UINT32                  FileId,
1047     void                    *Buffer,
1048     UINT32                  Length);
1049 
1050 void
1051 FlWriteFile (
1052     UINT32                  FileId,
1053     void                    *Buffer,
1054     UINT32                  Length);
1055 
1056 void
1057 FlSeekFile (
1058     UINT32                  FileId,
1059     long                    Offset);
1060 
1061 void
1062 FlSeekFileSet (
1063     UINT32                  FileId,
1064     long                    Offset);
1065 
1066 void
1067 FlCloseFile (
1068     UINT32                  FileId);
1069 
1070 ACPI_PRINTF_LIKE (2)
1071 void
1072 FlPrintFile (
1073     UINT32                  FileId,
1074     char                    *Format,
1075     ...);
1076 
1077 void
1078 FlDeleteFile (
1079     UINT32                  FileId);
1080 
1081 void
1082 FlSetLineNumber (
1083     UINT32                  LineNumber);
1084 
1085 void
1086 FlSetFilename (
1087     char                    *Filename);
1088 
1089 ACPI_STATUS
1090 FlOpenInputFile (
1091     char                    *InputFilename);
1092 
1093 ACPI_STATUS
1094 FlOpenAmlOutputFile (
1095     char                    *InputFilename);
1096 
1097 ACPI_STATUS
1098 FlOpenMiscOutputFiles (
1099     char                    *InputFilename);
1100 
1101 ACPI_STATUS
1102 FlInitOneFile (
1103     char                    *InputFilename);
1104 
1105 ASL_FILE_SWITCH_STATUS
1106 FlSwitchFileSet (
1107     char                    *InputFilename);
1108 
1109 FILE *
1110 FlGetFileHandle (
1111     UINT32                  OutFileId,
1112     UINT32                  InFileId,
1113     char                    *Filename);
1114 
1115 ASL_GLOBAL_FILE_NODE *
1116 FlGetFileNode (
1117     UINT32                  FileId,
1118     char                    *Filename);
1119 
1120 ASL_GLOBAL_FILE_NODE *
1121 FlGetCurrentFileNode (
1122     void);
1123 
1124 
1125 /*
1126  * aslhwmap - hardware map summary
1127  */
1128 void
1129 MpEmitMappingInfo (
1130     void);
1131 
1132 
1133 /*
1134  * asload - load namespace in prep for cross reference
1135  */
1136 ACPI_STATUS
1137 LdLoadNamespace (
1138     ACPI_PARSE_OBJECT       *RootOp);
1139 
1140 /*
1141  * asllookup - namespace lookup functions
1142  */
1143 void
1144 LkFindUnreferencedObjects (
1145     void);
1146 
1147 
1148 /*
1149  * aslhelp - help screens
1150  */
1151 void
1152 Usage (
1153     void);
1154 
1155 void
1156 AslFilenameHelp (
1157     void);
1158 
1159 void
1160 AslDisassemblyHelp (
1161     void);
1162 
1163 
1164 /*
1165  * aslnamesp - namespace output file generation
1166  */
1167 ACPI_STATUS
1168 NsDisplayNamespace (
1169     void);
1170 
1171 void
1172 NsSetupNamespaceListing (
1173     void                    *Handle);
1174 
1175 
1176 /*
1177  * asloptions - command line processing
1178  */
1179 int
1180 AslCommandLine (
1181     int                     argc,
1182     char                    **argv);
1183 
1184 
1185 /*
1186  * aslxref - namespace cross reference
1187  */
1188 ACPI_STATUS
1189 XfCrossReferenceNamespace (
1190     void);
1191 
1192 
1193 /*
1194  * aslxrefout
1195  */
1196 void
1197 OtPrintHeaders (
1198     char                    *Message);
1199 
1200 void
1201 OtCreateXrefFile (
1202     void);
1203 
1204 void
1205 OtXrefWalkPart1 (
1206     ACPI_PARSE_OBJECT       *Op,
1207     UINT32                  Level,
1208     ASL_METHOD_INFO         *MethodInfo);
1209 
1210 
1211 /*
1212  * aslutils - common compiler utilities
1213  */
1214 ACPI_PRINTF_LIKE(2)
1215 void
1216 DbgPrint (
1217     UINT32                  Type,
1218     char                    *Format,
1219     ...);
1220 
1221 /* Type values for above */
1222 
1223 #define ASL_DEBUG_OUTPUT    0
1224 #define ASL_PARSE_OUTPUT    1
1225 #define ASL_TREE_OUTPUT     2
1226 
1227 UINT8
1228 UtIsBigEndianMachine (
1229     void);
1230 
1231 BOOLEAN
1232 UtQueryForOverwrite (
1233     char                    *Pathname);
1234 
1235 void
1236 UtDumpStringOp (
1237     ACPI_PARSE_OBJECT       *Op,
1238     UINT32                  Level);
1239 
1240 void
1241 UtDumpIntegerOp (
1242     ACPI_PARSE_OBJECT       *Op,
1243     UINT32                  Level,
1244     UINT32                  IntegerLength);
1245 
1246 void
1247 UtDumpBasicOp (
1248     ACPI_PARSE_OBJECT       *Op,
1249     UINT32                  Level);
1250 
1251 ACPI_NAMESPACE_NODE *
1252 UtGetParentMethodNode (
1253     ACPI_NAMESPACE_NODE     *Node);
1254 
1255 ACPI_PARSE_OBJECT *
1256 UtGetParentMethodOp (
1257     ACPI_PARSE_OBJECT       *Op);
1258 
1259 BOOLEAN
1260 UtNodeIsDescendantOf (
1261     ACPI_NAMESPACE_NODE     *Node1,
1262     ACPI_NAMESPACE_NODE     *Node2);
1263 
1264 void
1265 UtDisplaySupportedTables (
1266     void);
1267 
1268 void
1269 UtDisplayConstantOpcodes (
1270     void);
1271 
1272 UINT8
1273 UtBeginEvent (
1274     char                    *Name);
1275 
1276 void
1277 UtEndEvent (
1278     UINT8                   Event);
1279 
1280 void
1281 UtDisplaySummary (
1282     UINT32                  FileId);
1283 
1284 void
1285 UtDisplayOneSummary (
1286     UINT32                  FileId,
1287     BOOLEAN                 DisplayErrorSummary);
1288 
1289 void
1290 UtConvertByteToHex (
1291     UINT8                   RawByte,
1292     UINT8                   *Buffer);
1293 
1294 void
1295 UtConvertByteToAsmHex (
1296     UINT8                   RawByte,
1297     UINT8                   *Buffer);
1298 
1299 char *
1300 UtGetOpName (
1301     UINT32                  ParseOpcode);
1302 
1303 void
1304 UtSetParseOpName (
1305     ACPI_PARSE_OBJECT       *Op);
1306 
1307 ACPI_STATUS
1308 UtInternalizeName (
1309     char                    *ExternalName,
1310     char                    **ConvertedName);
1311 
1312 BOOLEAN
1313 UtNameContainsAllPrefix (
1314     ACPI_PARSE_OBJECT       *Op);
1315 
1316 void
1317 UtAttachNamepathToOwner (
1318     ACPI_PARSE_OBJECT       *Op,
1319     ACPI_PARSE_OBJECT       *NameNode);
1320 
1321 ACPI_PARSE_OBJECT *
1322 UtCheckIntegerRange (
1323     ACPI_PARSE_OBJECT       *Op,
1324     UINT32                  LowValue,
1325     UINT32                  HighValue);
1326 
1327 UINT64
1328 UtDoConstant (
1329     char                    *String);
1330 
1331 char *
1332 AcpiUtStrdup (
1333     char                    *String);
1334 
1335 char *
1336 AcpiUtStrcat (
1337     char                    *String1,
1338     char                    *String2);
1339 
1340 
1341 /*
1342  * asluuid - UUID support
1343  */
1344 ACPI_STATUS
1345 AuValidateUuid (
1346     char                    *InString);
1347 
1348 ACPI_STATUS
1349 AuConvertUuidToString (
1350     char                    *UuIdBuffer,
1351     char                    *OutString);
1352 
1353 
1354 /*
1355  * aslresource - Resource template generation utilities
1356  */
1357 void
1358 RsSmallAddressCheck (
1359     UINT8                   Type,
1360     UINT32                  Minimum,
1361     UINT32                  Maximum,
1362     UINT32                  Length,
1363     UINT32                  Alignment,
1364     ACPI_PARSE_OBJECT       *MinOp,
1365     ACPI_PARSE_OBJECT       *MaxOp,
1366     ACPI_PARSE_OBJECT       *LengthOp,
1367     ACPI_PARSE_OBJECT       *AlignOp,
1368     ACPI_PARSE_OBJECT       *Op);
1369 
1370 void
1371 RsLargeAddressCheck (
1372     UINT64                  Minimum,
1373     UINT64                  Maximum,
1374     UINT64                  Length,
1375     UINT64                  Granularity,
1376     UINT8                   Flags,
1377     ACPI_PARSE_OBJECT       *MinOp,
1378     ACPI_PARSE_OBJECT       *MaxOp,
1379     ACPI_PARSE_OBJECT       *LengthOp,
1380     ACPI_PARSE_OBJECT       *GranOp,
1381     ACPI_PARSE_OBJECT       *Op);
1382 
1383 UINT16
1384 RsGetStringDataLength (
1385     ACPI_PARSE_OBJECT       *InitializerOp);
1386 
1387 ASL_RESOURCE_NODE *
1388 RsAllocateResourceNode (
1389     UINT32                  Size);
1390 
1391 void
1392 RsCreateResourceField (
1393     ACPI_PARSE_OBJECT       *Op,
1394     char                    *Name,
1395     UINT32                  ByteOffset,
1396     UINT32                  BitOffset,
1397     UINT32                  BitLength);
1398 
1399 void
1400 RsSetFlagBits (
1401     UINT8                   *Flags,
1402     ACPI_PARSE_OBJECT       *Op,
1403     UINT8                   Position,
1404     UINT8                   DefaultBit);
1405 
1406 void
1407 RsSetFlagBits16 (
1408     UINT16                  *Flags,
1409     ACPI_PARSE_OBJECT       *Op,
1410     UINT8                   Position,
1411     UINT8                   DefaultBit);
1412 
1413 ACPI_PARSE_OBJECT *
1414 RsCompleteNodeAndGetNext (
1415     ACPI_PARSE_OBJECT       *Op);
1416 
1417 void
1418 RsCheckListForDuplicates (
1419     ACPI_PARSE_OBJECT       *Op);
1420 
1421 ASL_RESOURCE_NODE *
1422 RsDoOneResourceDescriptor (
1423     ASL_RESOURCE_INFO       *Info,
1424     UINT8                   *State);
1425 
1426 /* Values for State above */
1427 
1428 #define ACPI_RSTATE_NORMAL              0
1429 #define ACPI_RSTATE_START_DEPENDENT     1
1430 #define ACPI_RSTATE_DEPENDENT_LIST      2
1431 
1432 UINT32
1433 RsLinkDescriptorChain (
1434     ASL_RESOURCE_NODE       **PreviousRnode,
1435     ASL_RESOURCE_NODE       *Rnode);
1436 
1437 void
1438 RsDoResourceTemplate (
1439     ACPI_PARSE_OBJECT       *Op);
1440 
1441 
1442 /*
1443  * aslrestype1 - Miscellaneous Small descriptors
1444  */
1445 ASL_RESOURCE_NODE *
1446 RsDoEndTagDescriptor (
1447     ASL_RESOURCE_INFO       *Info);
1448 
1449 ASL_RESOURCE_NODE *
1450 RsDoEndDependentDescriptor (
1451     ASL_RESOURCE_INFO       *Info);
1452 
1453 ASL_RESOURCE_NODE *
1454 RsDoMemory24Descriptor (
1455     ASL_RESOURCE_INFO       *Info);
1456 
1457 ASL_RESOURCE_NODE *
1458 RsDoMemory32Descriptor (
1459     ASL_RESOURCE_INFO       *Info);
1460 
1461 ASL_RESOURCE_NODE *
1462 RsDoMemory32FixedDescriptor (
1463     ASL_RESOURCE_INFO       *Info);
1464 
1465 ASL_RESOURCE_NODE *
1466 RsDoStartDependentDescriptor (
1467     ASL_RESOURCE_INFO       *Info);
1468 
1469 ASL_RESOURCE_NODE *
1470 RsDoStartDependentNoPriDescriptor (
1471     ASL_RESOURCE_INFO       *Info);
1472 
1473 ASL_RESOURCE_NODE *
1474 RsDoVendorSmallDescriptor (
1475     ASL_RESOURCE_INFO       *Info);
1476 
1477 
1478 /*
1479  * aslrestype1i - I/O-related Small descriptors
1480  */
1481 ASL_RESOURCE_NODE *
1482 RsDoDmaDescriptor (
1483     ASL_RESOURCE_INFO       *Info);
1484 
1485 ASL_RESOURCE_NODE *
1486 RsDoFixedDmaDescriptor (
1487     ASL_RESOURCE_INFO       *Info);
1488 
1489 ASL_RESOURCE_NODE *
1490 RsDoFixedIoDescriptor (
1491     ASL_RESOURCE_INFO       *Info);
1492 
1493 ASL_RESOURCE_NODE *
1494 RsDoIoDescriptor (
1495     ASL_RESOURCE_INFO       *Info);
1496 
1497 ASL_RESOURCE_NODE *
1498 RsDoIrqDescriptor (
1499     ASL_RESOURCE_INFO       *Info);
1500 
1501 ASL_RESOURCE_NODE *
1502 RsDoIrqNoFlagsDescriptor (
1503     ASL_RESOURCE_INFO       *Info);
1504 
1505 
1506 /*
1507  * aslrestype2 - Large resource descriptors
1508  */
1509 ASL_RESOURCE_NODE *
1510 RsDoInterruptDescriptor (
1511     ASL_RESOURCE_INFO       *Info);
1512 
1513 ASL_RESOURCE_NODE *
1514 RsDoVendorLargeDescriptor (
1515     ASL_RESOURCE_INFO       *Info);
1516 
1517 ASL_RESOURCE_NODE *
1518 RsDoGeneralRegisterDescriptor (
1519     ASL_RESOURCE_INFO       *Info);
1520 
1521 ASL_RESOURCE_NODE *
1522 RsDoGpioIntDescriptor (
1523     ASL_RESOURCE_INFO       *Info);
1524 
1525 ASL_RESOURCE_NODE *
1526 RsDoGpioIoDescriptor (
1527     ASL_RESOURCE_INFO       *Info);
1528 
1529 ASL_RESOURCE_NODE *
1530 RsDoI2cSerialBusDescriptor (
1531     ASL_RESOURCE_INFO       *Info);
1532 
1533 ASL_RESOURCE_NODE *
1534 RsDoSpiSerialBusDescriptor (
1535     ASL_RESOURCE_INFO       *Info);
1536 
1537 ASL_RESOURCE_NODE *
1538 RsDoUartSerialBusDescriptor (
1539     ASL_RESOURCE_INFO       *Info);
1540 
1541 ASL_RESOURCE_NODE *
1542 RsDoPinFunctionDescriptor (
1543     ASL_RESOURCE_INFO       *Info);
1544 
1545 ASL_RESOURCE_NODE *
1546 RsDoPinConfigDescriptor (
1547     ASL_RESOURCE_INFO       *Info);
1548 
1549 ASL_RESOURCE_NODE *
1550 RsDoPinGroupDescriptor (
1551     ASL_RESOURCE_INFO       *Info);
1552 
1553 ASL_RESOURCE_NODE *
1554 RsDoPinGroupFunctionDescriptor (
1555     ASL_RESOURCE_INFO       *Info);
1556 
1557 ASL_RESOURCE_NODE *
1558 RsDoPinGroupConfigDescriptor (
1559     ASL_RESOURCE_INFO       *Info);
1560 
1561 
1562 /*
1563  * aslrestype2d - DWord address descriptors
1564  */
1565 ASL_RESOURCE_NODE *
1566 RsDoDwordIoDescriptor (
1567     ASL_RESOURCE_INFO       *Info);
1568 
1569 ASL_RESOURCE_NODE *
1570 RsDoDwordMemoryDescriptor (
1571     ASL_RESOURCE_INFO       *Info);
1572 
1573 ASL_RESOURCE_NODE *
1574 RsDoDwordSpaceDescriptor (
1575     ASL_RESOURCE_INFO       *Info);
1576 
1577 
1578 /*
1579  * aslrestype2e - Extended address descriptors
1580  */
1581 ASL_RESOURCE_NODE *
1582 RsDoExtendedIoDescriptor (
1583     ASL_RESOURCE_INFO       *Info);
1584 
1585 ASL_RESOURCE_NODE *
1586 RsDoExtendedMemoryDescriptor (
1587     ASL_RESOURCE_INFO       *Info);
1588 
1589 ASL_RESOURCE_NODE *
1590 RsDoExtendedSpaceDescriptor (
1591     ASL_RESOURCE_INFO       *Info);
1592 
1593 
1594 /*
1595  * aslrestype2q - QWord address descriptors
1596  */
1597 ASL_RESOURCE_NODE *
1598 RsDoQwordIoDescriptor (
1599     ASL_RESOURCE_INFO       *Info);
1600 
1601 ASL_RESOURCE_NODE *
1602 RsDoQwordMemoryDescriptor (
1603     ASL_RESOURCE_INFO       *Info);
1604 
1605 ASL_RESOURCE_NODE *
1606 RsDoQwordSpaceDescriptor (
1607     ASL_RESOURCE_INFO       *Info);
1608 
1609 
1610 /*
1611  * aslrestype2w - Word address descriptors
1612  */
1613 ASL_RESOURCE_NODE *
1614 RsDoWordIoDescriptor (
1615     ASL_RESOURCE_INFO       *Info);
1616 
1617 ASL_RESOURCE_NODE *
1618 RsDoWordSpaceDescriptor (
1619     ASL_RESOURCE_INFO       *Info);
1620 
1621 ASL_RESOURCE_NODE *
1622 RsDoWordBusNumberDescriptor (
1623     ASL_RESOURCE_INFO       *Info);
1624 
1625 
1626 /*
1627  * Entry to data table compiler subsystem
1628  */
1629 ACPI_STATUS
1630 DtDoCompile(
1631     void);
1632 
1633 ACPI_STATUS
1634 DtCreateTemplates (
1635     char                    **argv);
1636 
1637 
1638 /*
1639  * ASL/ASL+ converter debug
1640  */
1641 ACPI_PRINTF_LIKE (1)
1642 void
1643 CvDbgPrint (
1644     char                    *Fmt,
1645     ...);
1646 
1647 
1648 #endif /*  __ASLCOMPILER_H */
1649