aslcompiler.h revision 207344 
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 - 2010, 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
122/* Microsoft-specific */
123
124#if (defined WIN32 || defined WIN64)
125
126/* warn : used #pragma pack */
127#pragma warning(disable:4103)
128
129/* warn : named type definition in parentheses */
130#pragma warning(disable:4115)
131#endif
132
133#include <stdio.h>
134#include <stdlib.h>
135#include <stdarg.h>
136#include <string.h>
137#include <errno.h>
138#include <ctype.h>
139
140
141#include <contrib/dev/acpica/include/acpi.h>
142#include <contrib/dev/acpica/include/accommon.h>
143#include <contrib/dev/acpica/include/amlresrc.h>
144#include <contrib/dev/acpica/include/acdebug.h>
145
146/* Compiler headers */
147
148#include <contrib/dev/acpica/compiler/asldefine.h>
149#include <contrib/dev/acpica/compiler/asltypes.h>
150#include <contrib/dev/acpica/compiler/aslglobal.h>
151
152
153/*******************************************************************************
154 *
155 * Compiler prototypes
156 *
157 ******************************************************************************/
158
159/*
160 * parser - generated from flex/bison, lex/yacc, etc.
161 */
162int
163AslCompilerparse(
164    void);
165
166ACPI_PARSE_OBJECT *
167AslDoError (
168    void);
169
170int
171AslCompilerlex(
172    void);
173
174void
175ResetCurrentLineBuffer (
176    void);
177
178void
179InsertLineBuffer (
180    int                     SourceChar);
181
182int
183AslPopInputFileStack (
184    void);
185
186void
187AslPushInputFileStack (
188    FILE                    *InputFile,
189    char                    *Filename);
190
191/*
192 * aslstartup - called from main
193 */
194ACPI_STATUS
195AslDoOnePathname (
196    char                    *Pathname);
197
198ACPI_STATUS
199AslDoOneFile (
200    char                    *Filename);
201
202/*
203 * aslcompile - compile mainline
204 */
205void
206AslCompilerSignon (
207    UINT32                  FileId);
208
209void
210AslCompilerFileHeader (
211    UINT32                  FileId);
212
213int
214CmDoCompile (
215    void);
216
217void
218CmDoOutputFiles (
219    void);
220
221void
222CmCleanupAndExit (
223    void);
224
225
226/*
227 * aslanalyze - semantic analysis
228 */
229ACPI_STATUS
230AnOtherSemanticAnalysisWalkBegin (
231    ACPI_PARSE_OBJECT       *Op,
232    UINT32                  Level,
233    void                    *Context);
234
235ACPI_STATUS
236AnOtherSemanticAnalysisWalkEnd (
237    ACPI_PARSE_OBJECT       *Op,
238    UINT32                  Level,
239    void                    *Context);
240
241ACPI_STATUS
242AnOperandTypecheckWalkBegin (
243    ACPI_PARSE_OBJECT       *Op,
244    UINT32                  Level,
245    void                    *Context);
246
247ACPI_STATUS
248AnOperandTypecheckWalkEnd (
249    ACPI_PARSE_OBJECT       *Op,
250    UINT32                  Level,
251    void                    *Context);
252
253ACPI_STATUS
254AnMethodAnalysisWalkBegin (
255    ACPI_PARSE_OBJECT       *Op,
256    UINT32                  Level,
257    void                    *Context);
258
259ACPI_STATUS
260AnMethodAnalysisWalkEnd (
261    ACPI_PARSE_OBJECT       *Op,
262    UINT32                  Level,
263    void                    *Context);
264
265ACPI_STATUS
266AnMethodTypingWalkBegin (
267    ACPI_PARSE_OBJECT       *Op,
268    UINT32                  Level,
269    void                    *Context);
270
271ACPI_STATUS
272AnMethodTypingWalkEnd (
273    ACPI_PARSE_OBJECT       *Op,
274    UINT32                  Level,
275    void                    *Context);
276
277
278/*
279 * aslerror - error handling/reporting
280 */
281void
282AslError (
283    UINT8                   Level,
284    UINT8                   MessageId,
285    ACPI_PARSE_OBJECT       *Op,
286    char                    *ExtraMessage);
287
288void
289AslCoreSubsystemError (
290    ACPI_PARSE_OBJECT       *Op,
291    ACPI_STATUS             Status,
292    char                    *ExtraMessage,
293    BOOLEAN                 Abort);
294
295int
296AslCompilererror(
297    char                    *s);
298
299void
300AslCommonError (
301    UINT8                   Level,
302    UINT8                   MessageId,
303    UINT32                  CurrentLineNumber,
304    UINT32                  LogicalLineNumber,
305    UINT32                  LogicalByteOffset,
306    UINT32                  Column,
307    char                    *Filename,
308    char                    *ExtraMessage);
309
310void
311AePrintException (
312    UINT32                  FileId,
313    ASL_ERROR_MSG           *Enode,
314    char                    *Header);
315
316void
317AePrintErrorLog (
318    UINT32                  FileId);
319
320void
321AeClearErrorLog (
322    void);
323
324ACPI_PHYSICAL_ADDRESS
325AeLocalGetRootPointer (
326    void);
327
328
329/*
330 * asllisting - generate all "listing" type files
331 */
332void
333LsDoListings (
334    void);
335
336void
337LsWriteNodeToAsmListing (
338    ACPI_PARSE_OBJECT       *Op);
339
340void
341LsWriteNode (
342    ACPI_PARSE_OBJECT       *Op,
343    UINT32                  FileId);
344
345void
346LsDoHexOutput (
347    void);
348
349void
350LsDumpParseTree (
351    void);
352
353/*
354 * aslfold - constant folding
355 */
356ACPI_STATUS
357OpcAmlConstantWalk (
358    ACPI_PARSE_OBJECT       *Op,
359    UINT32                  Level,
360    void                    *Context);
361
362
363/*
364 * aslopcodes - generate AML opcodes
365 */
366ACPI_STATUS
367OpcAmlOpcodeWalk (
368    ACPI_PARSE_OBJECT       *Op,
369    UINT32                  Level,
370    void                    *Context);
371
372ACPI_STATUS
373OpcAmlOpcodeUpdateWalk (
374    ACPI_PARSE_OBJECT       *Op,
375    UINT32                  Level,
376    void                    *Context);
377
378void
379OpcGenerateAmlOpcode (
380    ACPI_PARSE_OBJECT       *Op);
381
382UINT32
383OpcSetOptimalIntegerSize (
384    ACPI_PARSE_OBJECT       *Op);
385
386void
387OpcGetIntegerWidth (
388    ACPI_PARSE_OBJECT       *Op);
389
390
391/*
392 * asloperands - generate AML operands for the AML opcodes
393 */
394ACPI_PARSE_OBJECT  *
395UtGetArg (
396    ACPI_PARSE_OBJECT       *Op,
397    UINT32                  Argn);
398
399void
400OpnGenerateAmlOperands (
401    ACPI_PARSE_OBJECT       *Op);
402
403void
404OpnDoPackage (
405    ACPI_PARSE_OBJECT       *Op);
406
407
408/*
409 * aslopt - optmization
410 */
411void
412OptOptimizeNamePath (
413    ACPI_PARSE_OBJECT       *Op,
414    UINT32                  Flags,
415    ACPI_WALK_STATE         *WalkState,
416    char                    *AmlNameString,
417    ACPI_NAMESPACE_NODE     *TargetNode);
418
419
420/*
421 * aslcodegen - code generation
422 */
423void
424CgGenerateAmlOutput (
425    void);
426
427
428/*
429 * asllength - calculate/adjust AML package lengths
430 */
431ACPI_STATUS
432LnPackageLengthWalk (
433    ACPI_PARSE_OBJECT       *Op,
434    UINT32                  Level,
435    void                    *Context);
436
437ACPI_STATUS
438LnInitLengthsWalk (
439    ACPI_PARSE_OBJECT       *Op,
440    UINT32                  Level,
441    void                    *Context);
442
443void
444CgGenerateAmlLengths (
445    ACPI_PARSE_OBJECT       *Op);
446
447
448/*
449 * aslmap - opcode mappings and reserved method names
450 */
451ACPI_OBJECT_TYPE
452AslMapNamedOpcodeToDataType (
453    UINT16                  Opcode);
454
455
456/*
457 * aslpredef - ACPI predefined names support
458 */
459void
460ApCheckForPredefinedMethod (
461    ACPI_PARSE_OBJECT       *Op,
462    ASL_METHOD_INFO         *MethodInfo);
463
464void
465ApCheckPredefinedReturnValue (
466    ACPI_PARSE_OBJECT       *Op,
467    ASL_METHOD_INFO         *MethodInfo);
468
469UINT32
470ApCheckForPredefinedName (
471    ACPI_PARSE_OBJECT       *Op,
472    char                    *Name);
473
474void
475ApCheckForPredefinedObject (
476    ACPI_PARSE_OBJECT       *Op,
477    char                    *Name);
478
479void
480ApDisplayReservedNames (
481    void);
482
483
484/*
485 * asltransform - parse tree transformations
486 */
487ACPI_STATUS
488TrAmlTransformWalk (
489    ACPI_PARSE_OBJECT       *Op,
490    UINT32                  Level,
491    void                    *Context);
492
493
494/*
495 * asltree - parse tree support
496 */
497ACPI_STATUS
498TrWalkParseTree (
499    ACPI_PARSE_OBJECT       *Op,
500    UINT32                  Visitation,
501    ASL_WALK_CALLBACK       DescendingCallback,
502    ASL_WALK_CALLBACK       AscendingCallback,
503    void                    *Context);
504
505/* Values for "Visitation" parameter above */
506
507#define ASL_WALK_VISIT_DOWNWARD     0x01
508#define ASL_WALK_VISIT_UPWARD       0x02
509#define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
510
511
512ACPI_PARSE_OBJECT *
513TrAllocateNode (
514    UINT32                  ParseOpcode);
515
516void
517TrReleaseNode (
518    ACPI_PARSE_OBJECT       *Op);
519
520ACPI_PARSE_OBJECT *
521TrUpdateNode (
522    UINT32                  ParseOpcode,
523    ACPI_PARSE_OBJECT       *Op);
524
525ACPI_PARSE_OBJECT *
526TrCreateNode (
527    UINT32                  ParseOpcode,
528    UINT32                  NumChildren,
529    ...);
530
531ACPI_PARSE_OBJECT *
532TrCreateLeafNode (
533    UINT32                  ParseOpcode);
534
535ACPI_PARSE_OBJECT *
536TrCreateValuedLeafNode (
537    UINT32                  ParseOpcode,
538    UINT64                  Value);
539
540ACPI_PARSE_OBJECT *
541TrLinkChildren (
542    ACPI_PARSE_OBJECT       *Op,
543    UINT32                  NumChildren,
544    ...);
545
546void
547TrSetEndLineNumber (
548    ACPI_PARSE_OBJECT       *Op);
549
550void
551TrWalkTree (
552    void);
553
554ACPI_PARSE_OBJECT *
555TrLinkPeerNode (
556    ACPI_PARSE_OBJECT       *Op1,
557    ACPI_PARSE_OBJECT       *Op2);
558
559ACPI_PARSE_OBJECT *
560TrLinkChildNode (
561    ACPI_PARSE_OBJECT       *Op1,
562    ACPI_PARSE_OBJECT       *Op2);
563
564ACPI_PARSE_OBJECT *
565TrSetNodeFlags (
566    ACPI_PARSE_OBJECT       *Op,
567    UINT32                  Flags);
568
569ACPI_PARSE_OBJECT *
570TrLinkPeerNodes (
571    UINT32                  NumPeers,
572    ...);
573
574
575/*
576 * aslfiles - File I/O support
577 */
578void
579AslAbort (
580    void);
581
582void
583FlAddIncludeDirectory (
584    char                    *Dir);
585
586void
587FlOpenIncludeFile (
588    ACPI_PARSE_OBJECT       *Op);
589
590void
591FlFileError (
592    UINT32                  FileId,
593    UINT8                   ErrorId);
594
595UINT32
596FlGetFileSize (
597    UINT32                  FileId);
598
599ACPI_STATUS
600FlReadFile (
601    UINT32                  FileId,
602    void                    *Buffer,
603    UINT32                  Length);
604
605void
606FlWriteFile (
607    UINT32                  FileId,
608    void                    *Buffer,
609    UINT32                  Length);
610
611void
612FlSeekFile (
613    UINT32                  FileId,
614    long                    Offset);
615
616void
617FlCloseFile (
618    UINT32                  FileId);
619
620void
621FlPrintFile (
622    UINT32                  FileId,
623    char                    *Format,
624    ...);
625
626void
627FlSetLineNumber (
628    ACPI_PARSE_OBJECT       *Op);
629
630ACPI_STATUS
631FlOpenInputFile (
632    char                    *InputFilename);
633
634ACPI_STATUS
635FlOpenAmlOutputFile (
636    char                    *InputFilename);
637
638ACPI_STATUS
639FlOpenMiscOutputFiles (
640    char                    *InputFilename);
641
642
643/*
644 * asload - load namespace in prep for cross reference
645 */
646ACPI_STATUS
647LdLoadNamespace (
648    ACPI_PARSE_OBJECT       *RootOp);
649
650
651/*
652 * asllookup - namespace cross reference
653 */
654ACPI_STATUS
655LkCrossReferenceNamespace (
656    void);
657
658void
659LkFindUnreferencedObjects (
660    void);
661
662ACPI_STATUS
663LsDisplayNamespace (
664    void);
665
666
667/*
668 * aslutils - common compiler utilites
669 */
670void
671DbgPrint (
672    UINT32                  Type,
673    char                    *Format,
674    ...);
675
676/* Type values for above */
677
678#define ASL_DEBUG_OUTPUT    0
679#define ASL_PARSE_OUTPUT    1
680#define ASL_TREE_OUTPUT     2
681
682void
683UtDisplayConstantOpcodes (
684    void);
685
686UINT8
687UtBeginEvent (
688    char                    *Name);
689
690void
691UtEndEvent (
692    UINT8                   Event);
693
694void *
695UtLocalCalloc (
696    UINT32                  Size);
697
698void
699UtPrintFormattedName (
700    UINT16                  ParseOpcode,
701    UINT32                  Level);
702
703void
704UtDisplaySummary (
705    UINT32                  FileId);
706
707UINT8
708UtHexCharToValue (
709    int                     HexChar);
710
711void
712UtConvertByteToHex (
713    UINT8                   RawByte,
714    UINT8                   *Buffer);
715
716void
717UtConvertByteToAsmHex (
718    UINT8                   RawByte,
719    UINT8                   *Buffer);
720
721char *
722UtGetOpName (
723    UINT32                  ParseOpcode);
724
725void
726UtSetParseOpName (
727    ACPI_PARSE_OBJECT       *Op);
728
729char *
730UtGetStringBuffer (
731    UINT32                  Length);
732
733ACPI_STATUS
734UtInternalizeName (
735    char                    *ExternalName,
736    char                    **ConvertedName);
737
738void
739UtAttachNamepathToOwner (
740    ACPI_PARSE_OBJECT       *Op,
741    ACPI_PARSE_OBJECT       *NameNode);
742
743ACPI_PARSE_OBJECT *
744UtCheckIntegerRange (
745    ACPI_PARSE_OBJECT       *Op,
746    UINT32                  LowValue,
747    UINT32                  HighValue);
748
749UINT64
750UtDoConstant (
751    char                    *String);
752
753
754/*
755 * aslresource - Resource template generation utilities
756 */
757void
758RsSmallAddressCheck (
759    UINT8                   Type,
760    UINT32                  Minimum,
761    UINT32                  Maximum,
762    UINT32                  Length,
763    UINT32                  Alignment,
764    ACPI_PARSE_OBJECT       *MinOp,
765    ACPI_PARSE_OBJECT       *MaxOp,
766    ACPI_PARSE_OBJECT       *LengthOp,
767    ACPI_PARSE_OBJECT       *AlignOp);
768
769void
770RsLargeAddressCheck (
771    UINT64                  Minimum,
772    UINT64                  Maximum,
773    UINT64                  Length,
774    UINT64                  Granularity,
775    UINT8                   Flags,
776    ACPI_PARSE_OBJECT       *MinOp,
777    ACPI_PARSE_OBJECT       *MaxOp,
778    ACPI_PARSE_OBJECT       *LengthOp,
779    ACPI_PARSE_OBJECT       *GranOp);
780
781UINT16
782RsGetStringDataLength (
783    ACPI_PARSE_OBJECT       *InitializerOp);
784
785ASL_RESOURCE_NODE *
786RsAllocateResourceNode (
787    UINT32                  Size);
788
789void
790RsCreateBitField (
791    ACPI_PARSE_OBJECT       *Op,
792    char                    *Name,
793    UINT32                  ByteOffset,
794    UINT32                  BitOffset);
795
796void
797RsCreateByteField (
798    ACPI_PARSE_OBJECT       *Op,
799    char                    *Name,
800    UINT32                  ByteOffset);
801
802void
803RsSetFlagBits (
804    UINT8                   *Flags,
805    ACPI_PARSE_OBJECT       *Op,
806    UINT8                   Position,
807    UINT8                   DefaultBit);
808
809ACPI_PARSE_OBJECT *
810RsCompleteNodeAndGetNext (
811    ACPI_PARSE_OBJECT       *Op);
812
813void
814RsCheckListForDuplicates (
815    ACPI_PARSE_OBJECT       *Op);
816
817ASL_RESOURCE_NODE *
818RsDoOneResourceDescriptor (
819    ACPI_PARSE_OBJECT       *DescriptorTypeOp,
820    UINT32                  CurrentByteOffset,
821    UINT8                   *State);
822
823/* Values for State above */
824
825#define ACPI_RSTATE_NORMAL              0
826#define ACPI_RSTATE_START_DEPENDENT     1
827#define ACPI_RSTATE_DEPENDENT_LIST      2
828
829UINT32
830RsLinkDescriptorChain (
831    ASL_RESOURCE_NODE       **PreviousRnode,
832    ASL_RESOURCE_NODE       *Rnode);
833
834void
835RsDoResourceTemplate (
836    ACPI_PARSE_OBJECT       *Op);
837
838
839/*
840 * aslrestype1 - Miscellaneous Small descriptors
841 */
842ASL_RESOURCE_NODE *
843RsDoEndTagDescriptor (
844    ACPI_PARSE_OBJECT       *Op,
845    UINT32                  CurrentByteOffset);
846
847ASL_RESOURCE_NODE *
848RsDoEndDependentDescriptor (
849    ACPI_PARSE_OBJECT       *Op,
850    UINT32                  CurrentByteOffset);
851
852ASL_RESOURCE_NODE *
853RsDoMemory24Descriptor (
854    ACPI_PARSE_OBJECT       *Op,
855    UINT32                  CurrentByteOffset);
856
857ASL_RESOURCE_NODE *
858RsDoMemory32Descriptor (
859    ACPI_PARSE_OBJECT       *Op,
860    UINT32                  CurrentByteOffset);
861
862ASL_RESOURCE_NODE *
863RsDoMemory32FixedDescriptor (
864    ACPI_PARSE_OBJECT       *Op,
865    UINT32                  CurrentByteOffset);
866
867ASL_RESOURCE_NODE *
868RsDoStartDependentDescriptor (
869    ACPI_PARSE_OBJECT       *Op,
870    UINT32                  CurrentByteOffset);
871
872ASL_RESOURCE_NODE *
873RsDoStartDependentNoPriDescriptor (
874    ACPI_PARSE_OBJECT       *Op,
875    UINT32                  CurrentByteOffset);
876
877ASL_RESOURCE_NODE *
878RsDoVendorSmallDescriptor (
879    ACPI_PARSE_OBJECT       *Op,
880    UINT32                  CurrentByteOffset);
881
882
883/*
884 * aslrestype1i - I/O-related Small descriptors
885 */
886ASL_RESOURCE_NODE *
887RsDoDmaDescriptor (
888    ACPI_PARSE_OBJECT       *Op,
889    UINT32                  CurrentByteOffset);
890
891ASL_RESOURCE_NODE *
892RsDoFixedIoDescriptor (
893    ACPI_PARSE_OBJECT       *Op,
894    UINT32                  CurrentByteOffset);
895
896ASL_RESOURCE_NODE *
897RsDoIoDescriptor (
898    ACPI_PARSE_OBJECT       *Op,
899    UINT32                  CurrentByteOffset);
900
901ASL_RESOURCE_NODE *
902RsDoIrqDescriptor (
903    ACPI_PARSE_OBJECT       *Op,
904    UINT32                  CurrentByteOffset);
905
906ASL_RESOURCE_NODE *
907RsDoIrqNoFlagsDescriptor (
908    ACPI_PARSE_OBJECT       *Op,
909    UINT32                  CurrentByteOffset);
910
911
912/*
913 * aslrestype2 - Large resource descriptors
914 */
915ASL_RESOURCE_NODE *
916RsDoInterruptDescriptor (
917    ACPI_PARSE_OBJECT       *Op,
918    UINT32                  CurrentByteOffset);
919
920ASL_RESOURCE_NODE *
921RsDoVendorLargeDescriptor (
922    ACPI_PARSE_OBJECT       *Op,
923    UINT32                  CurrentByteOffset);
924
925ASL_RESOURCE_NODE *
926RsDoGeneralRegisterDescriptor (
927    ACPI_PARSE_OBJECT       *Op,
928    UINT32                  CurrentByteOffset);
929
930
931/*
932 * aslrestype2d - DWord address descriptors
933 */
934ASL_RESOURCE_NODE *
935RsDoDwordIoDescriptor (
936    ACPI_PARSE_OBJECT       *Op,
937    UINT32                  CurrentByteOffset);
938
939ASL_RESOURCE_NODE *
940RsDoDwordMemoryDescriptor (
941    ACPI_PARSE_OBJECT       *Op,
942    UINT32                  CurrentByteOffset);
943
944ASL_RESOURCE_NODE *
945RsDoDwordSpaceDescriptor (
946    ACPI_PARSE_OBJECT       *Op,
947    UINT32                  CurrentByteOffset);
948
949
950/*
951 * aslrestype2e - Extended address descriptors
952 */
953ASL_RESOURCE_NODE *
954RsDoExtendedIoDescriptor (
955    ACPI_PARSE_OBJECT       *Op,
956    UINT32                  CurrentByteOffset);
957
958ASL_RESOURCE_NODE *
959RsDoExtendedMemoryDescriptor (
960    ACPI_PARSE_OBJECT       *Op,
961    UINT32                  CurrentByteOffset);
962
963ASL_RESOURCE_NODE *
964RsDoExtendedSpaceDescriptor (
965    ACPI_PARSE_OBJECT       *Op,
966    UINT32                  CurrentByteOffset);
967
968
969/*
970 * aslrestype2q - QWord address descriptors
971 */
972ASL_RESOURCE_NODE *
973RsDoQwordIoDescriptor (
974    ACPI_PARSE_OBJECT       *Op,
975    UINT32                  CurrentByteOffset);
976
977ASL_RESOURCE_NODE *
978RsDoQwordMemoryDescriptor (
979    ACPI_PARSE_OBJECT       *Op,
980    UINT32                  CurrentByteOffset);
981
982ASL_RESOURCE_NODE *
983RsDoQwordSpaceDescriptor (
984    ACPI_PARSE_OBJECT       *Op,
985    UINT32                  CurrentByteOffset);
986
987
988/*
989 * aslrestype2w - Word address descriptors
990 */
991ASL_RESOURCE_NODE *
992RsDoWordIoDescriptor (
993    ACPI_PARSE_OBJECT       *Op,
994    UINT32                  CurrentByteOffset);
995
996ASL_RESOURCE_NODE *
997RsDoWordSpaceDescriptor (
998    ACPI_PARSE_OBJECT       *Op,
999    UINT32                  CurrentByteOffset);
1000
1001ASL_RESOURCE_NODE *
1002RsDoWordBusNumberDescriptor (
1003    ACPI_PARSE_OBJECT       *Op,
1004    UINT32                  CurrentByteOffset);
1005
1006#endif /*  __ASLCOMPILER_H */
1007
1008