sys/contrib/dev/acpica/compiler/aslcompiler.h

   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 - 2017, 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 <contrib/dev/acpica/include/acpi.h>
 156 #include <contrib/dev/acpica/include/accommon.h>
 157 #include <contrib/dev/acpica/include/amlresrc.h>
 158 #include <contrib/dev/acpica/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 <contrib/dev/acpica/compiler/asldefine.h>
 180 #include <contrib/dev/acpica/compiler/asltypes.h>
 181 #include <contrib/dev/acpica/compiler/aslmessages.h>
 182 #include <contrib/dev/acpica/compiler/aslglobal.h>
 183 #include <contrib/dev/acpica/compiler/preprocess.h>
 184 #include <contrib/dev/acpica/compiler/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 int
 258 CmDoCompile (
 259     void);
 260
 261 void
 262 CmDoOutputFiles (
 263     void);
 264
 265 void
 266 CmCleanupAndExit (
 267     void);
 268
 269
 270 /*
 271  * aslallocate - memory allocation
 272  */
 273 void *
 274 UtLocalCalloc (
 275     UINT32                  Size);
 276
 277 void
 278 UtExpandLineBuffers (
 279     void);
 280
 281 void
 282 UtReallocLineBuffers (
 283     char                    **Buffer,
 284     UINT32                  OldSize,
 285     UINT32                  NewSize);
 286
 287 void
 288 UtFreeLineBuffers (
 289     void);
 290
 291
 292 /*
 293  * aslcache - local cache support
 294  */
 295 char *
 296 UtLocalCacheCalloc (
 297     UINT32                  Length);
 298
 299 ACPI_PARSE_OBJECT *
 300 UtParseOpCacheCalloc (
 301     void);
 302
 303 DT_SUBTABLE *
 304 UtSubtableCacheCalloc (
 305     void);
 306
 307 DT_FIELD *
 308 UtFieldCacheCalloc (
 309     void);
 310
 311 void
 312 UtDeleteLocalCaches (
 313     void);
 314
 315
 316 /*
 317  * aslascii - ascii support
 318  */
 319 ACPI_STATUS
 320 FlIsFileAsciiSource (
 321     char                    *Filename,
 322     BOOLEAN                 DisplayErrors);
 323
 324
 325 /*
 326  * aslwalks - semantic analysis and parse tree walks
 327  */
 328 ACPI_STATUS
 329 AnOtherSemanticAnalysisWalkBegin (
 330     ACPI_PARSE_OBJECT       *Op,
 331     UINT32                  Level,
 332     void                    *Context);
 333
 334 ACPI_STATUS
 335 AnOtherSemanticAnalysisWalkEnd (
 336     ACPI_PARSE_OBJECT       *Op,
 337     UINT32                  Level,
 338     void                    *Context);
 339
 340 ACPI_STATUS
 341 AnOperandTypecheckWalkEnd (
 342     ACPI_PARSE_OBJECT       *Op,
 343     UINT32                  Level,
 344     void                    *Context);
 345
 346 ACPI_STATUS
 347 AnMethodTypingWalkEnd (
 348     ACPI_PARSE_OBJECT       *Op,
 349     UINT32                  Level,
 350     void                    *Context);
 351
 352
 353 /*
 354  * aslmethod - Control method analysis walk
 355  */
 356 ACPI_STATUS
 357 MtMethodAnalysisWalkBegin (
 358     ACPI_PARSE_OBJECT       *Op,
 359     UINT32                  Level,
 360     void                    *Context);
 361
 362 ACPI_STATUS
 363 MtMethodAnalysisWalkEnd (
 364     ACPI_PARSE_OBJECT       *Op,
 365     UINT32                  Level,
 366     void                    *Context);
 367
 368
 369 /*
 370  * aslbtypes - bitfield data types
 371  */
 372 UINT32
 373 AnMapObjTypeToBtype (
 374     ACPI_PARSE_OBJECT       *Op);
 375
 376 UINT32
 377 AnMapArgTypeToBtype (
 378     UINT32                  ArgType);
 379
 380 UINT32
 381 AnGetBtype (
 382     ACPI_PARSE_OBJECT       *Op);
 383
 384 void
 385 AnFormatBtype (
 386     char                    *Buffer,
 387     UINT32                  Btype);
 388
 389
 390 /*
 391  * aslanalyze - Support functions for parse tree walks
 392  */
 393 void
 394 AnCheckId (
 395     ACPI_PARSE_OBJECT       *Op,
 396     ACPI_NAME               Type);
 397
 398 /* Values for Type argument above */
 399
 400 #define ASL_TYPE_HID        0
 401 #define ASL_TYPE_CID        1
 402
 403 BOOLEAN
 404 AnIsInternalMethod (
 405     ACPI_PARSE_OBJECT       *Op);
 406
 407 UINT32
 408 AnGetInternalMethodReturnType (
 409     ACPI_PARSE_OBJECT       *Op);
 410
 411 BOOLEAN
 412 AnLastStatementIsReturn (
 413     ACPI_PARSE_OBJECT       *Op);
 414
 415 void
 416 AnCheckMethodReturnValue (
 417     ACPI_PARSE_OBJECT       *Op,
 418     const ACPI_OPCODE_INFO  *OpInfo,
 419     ACPI_PARSE_OBJECT       *ArgOp,
 420     UINT32                  RequiredBtypes,
 421     UINT32                  ThisNodeBtype);
 422
 423 BOOLEAN
 424 AnIsResultUsed (
 425     ACPI_PARSE_OBJECT       *Op);
 426
 427 void
 428 ApCheckForGpeNameConflict (
 429     ACPI_PARSE_OBJECT       *Op);
 430
 431 void
 432 ApCheckRegMethod (
 433     ACPI_PARSE_OBJECT       *Op);
 434
 435 BOOLEAN
 436 ApFindNameInScope (
 437     char                    *Name,
 438     ACPI_PARSE_OBJECT       *Op);
 439
 440 BOOLEAN
 441 ApFindNameInDeviceTree (
 442     char                    *Name,
 443     ACPI_PARSE_OBJECT       *Op);
 444
 445 /*
 446  * aslerror - error handling/reporting
 447  */
 448 void
 449 AslAbort (
 450     void);
 451
 452 void
 453 AslDualParseOpError (
 454     UINT8                   Level,
 455     UINT16                  MainMessageId,
 456     ACPI_PARSE_OBJECT       *MainOp,
 457     char                    *MainMessage,
 458     UINT16                  SecondMessageId,
 459     ACPI_PARSE_OBJECT       *SecondOp,
 460     char                    *SecondaryMessage);
 461
 462 void
 463 AslError (
 464     UINT8                   Level,
 465     UINT16                  MessageId,
 466     ACPI_PARSE_OBJECT       *Op,
 467     char                    *ExtraMessage);
 468
 469 void
 470 AslCheckExpectedExceptions (
 471     void);
 472
 473 ACPI_STATUS
 474 AslExpectException (
 475     char                    *MessageIdString);
 476
 477 ACPI_STATUS
 478 AslDisableException (
 479     char                    *MessageIdString);
 480
 481 BOOLEAN
 482 AslIsExceptionIgnored (
 483     UINT8                   Level,
 484     UINT16                  MessageId);
 485
 486 void
 487 AslCoreSubsystemError (
 488     ACPI_PARSE_OBJECT       *Op,
 489     ACPI_STATUS             Status,
 490     char                    *ExtraMessage,
 491     BOOLEAN                 Abort);
 492
 493 int
 494 AslCompilererror(
 495     const char              *s);
 496
 497 void
 498 AslCommonError (
 499     UINT8                   Level,
 500     UINT16                  MessageId,
 501     UINT32                  CurrentLineNumber,
 502     UINT32                  LogicalLineNumber,
 503     UINT32                  LogicalByteOffset,
 504     UINT32                  Column,
 505     char                    *Filename,
 506     char                    *ExtraMessage);
 507
 508 void
 509 AslCommonError2 (
 510     UINT8                   Level,
 511     UINT16                  MessageId,
 512     UINT32                  LineNumber,
 513     UINT32                  Column,
 514     char                    *SourceLine,
 515     char                    *Filename,
 516     char                    *ExtraMessage);
 517
 518 void
 519 AePrintException (
 520     UINT32                  FileId,
 521     ASL_ERROR_MSG           *Enode,
 522     char                    *Header);
 523
 524 void
 525 AePrintErrorLog (
 526     UINT32                  FileId);
 527
 528 void
 529 AeClearErrorLog (
 530     void);
 531
 532
 533 /*
 534  * asllisting - generate all "listing" type files
 535  */
 536 void
 537 LsDoListings (
 538     void);
 539
 540 void
 541 LsWriteNodeToAsmListing (
 542     ACPI_PARSE_OBJECT       *Op);
 543
 544 void
 545 LsWriteNode (
 546     ACPI_PARSE_OBJECT       *Op,
 547     UINT32                  FileId);
 548
 549 void
 550 LsDumpParseTree (
 551     void);
 552
 553
 554 /*
 555  * asllistsup - Listing file support utilities
 556  */
 557 void
 558 LsDumpAscii (
 559     UINT32                  FileId,
 560     UINT32                  Count,
 561     UINT8                   *Buffer);
 562
 563 void
 564 LsDumpAsciiInComment (
 565     UINT32                  FileId,
 566     UINT32                  Count,
 567     UINT8                   *Buffer);
 568
 569 void
 570 LsCheckException (
 571     UINT32                  LineNumber,
 572     UINT32                  FileId);
 573
 574 void
 575 LsFlushListingBuffer (
 576     UINT32                  FileId);
 577
 578 void
 579 LsWriteListingHexBytes (
 580     UINT8                   *Buffer,
 581     UINT32                  Length,
 582     UINT32                  FileId);
 583
 584 void
 585 LsWriteSourceLines (
 586     UINT32                  ToLineNumber,
 587     UINT32                  ToLogicalLineNumber,
 588     UINT32                  FileId);
 589
 590 UINT32
 591 LsWriteOneSourceLine (
 592     UINT32                  FileId);
 593
 594 void
 595 LsPushNode (
 596     char                    *Filename);
 597
 598 ASL_LISTING_NODE *
 599 LsPopNode (
 600     void);
 601
 602
 603 /*
 604  * aslhex - generate all "hex" output files (C, ASM, ASL)
 605  */
 606 void
 607 HxDoHexOutput (
 608     void);
 609
 610
 611 /*
 612  * aslfold - constant folding
 613  */
 614 ACPI_STATUS
 615 OpcAmlConstantWalk (
 616     ACPI_PARSE_OBJECT       *Op,
 617     UINT32                  Level,
 618     void                    *Context);
 619
 620
 621 /*
 622  * aslmessages - exception strings
 623  */
 624 const char *
 625 AeDecodeMessageId (
 626     UINT16                  MessageId);
 627
 628 const char *
 629 AeDecodeExceptionLevel (
 630     UINT8                   Level);
 631
 632 UINT16
 633 AeBuildFullExceptionCode (
 634     UINT8                   Level,
 635     UINT16                  MessageId);
 636
 637 /*
 638  * asloffset - generate C offset file for BIOS support
 639  */
 640 ACPI_STATUS
 641 LsAmlOffsetWalk (
 642     ACPI_PARSE_OBJECT       *Op,
 643     UINT32                  Level,
 644     void                    *Context);
 645
 646 void
 647 LsDoOffsetTableHeader (
 648     UINT32                  FileId);
 649
 650 void
 651 LsDoOffsetTableFooter (
 652     UINT32                  FileId);
 653
 654
 655 /*
 656  * aslopcodes - generate AML opcodes
 657  */
 658 ACPI_STATUS
 659 OpcAmlOpcodeWalk (
 660     ACPI_PARSE_OBJECT       *Op,
 661     UINT32                  Level,
 662     void                    *Context);
 663
 664 ACPI_STATUS
 665 OpcAmlOpcodeUpdateWalk (
 666     ACPI_PARSE_OBJECT       *Op,
 667     UINT32                  Level,
 668     void                    *Context);
 669
 670 void
 671 OpcGenerateAmlOpcode (
 672     ACPI_PARSE_OBJECT       *Op);
 673
 674 UINT32
 675 OpcSetOptimalIntegerSize (
 676     ACPI_PARSE_OBJECT       *Op);
 677
 678 void
 679 OpcGetIntegerWidth (
 680     ACPI_PARSE_OBJECT       *Op);
 681
 682
 683 /*
 684  * asloperands - generate AML operands for the AML opcodes
 685  */
 686 ACPI_PARSE_OBJECT  *
 687 UtGetArg (
 688     ACPI_PARSE_OBJECT       *Op,
 689     UINT32                  Argn);
 690
 691 void
 692 OpnGenerateAmlOperands (
 693     ACPI_PARSE_OBJECT       *Op);
 694
 695 void
 696 OpnDoPackage (
 697     ACPI_PARSE_OBJECT       *Op);
 698
 699
 700 /*
 701  * aslopt - optmization
 702  */
 703 void
 704 OptOptimizeNamePath (
 705     ACPI_PARSE_OBJECT       *Op,
 706     UINT32                  Flags,
 707     ACPI_WALK_STATE         *WalkState,
 708     char                    *AmlNameString,
 709     ACPI_NAMESPACE_NODE     *TargetNode);
 710
 711
 712 /*
 713  * aslpld - ToPLD macro support
 714  */
 715 void
 716 OpcDoPld (
 717     ACPI_PARSE_OBJECT       *Op);
 718
 719
 720 /*
 721  * aslprintf - Printf/Fprintf macros
 722  */
 723 void
 724 OpcDoPrintf (
 725     ACPI_PARSE_OBJECT       *Op);
 726
 727 void
 728 OpcDoFprintf (
 729     ACPI_PARSE_OBJECT       *Op);
 730
 731
 732 /*
 733  * aslprune - parse tree pruner
 734  */
 735 void
 736 AslPruneParseTree (
 737     UINT32                  PruneDepth,
 738     UINT32                  Type);
 739
 740
 741 /*
 742  * aslcodegen - code generation
 743  */
 744 void
 745 CgGenerateAmlOutput (
 746     void);
 747
 748 void
 749 CgLocalWriteAmlData (
 750     ACPI_PARSE_OBJECT       *Op,
 751     void                    *Buffer,
 752     UINT32                  Length);
 753
 754
 755 /*
 756  * aslfile
 757  */
 758 void
 759 FlOpenFile (
 760     UINT32                  FileId,
 761     char                    *Filename,
 762     char                    *Mode);
 763
 764
 765 /*
 766  * asllength - calculate/adjust AML package lengths
 767  */
 768 ACPI_STATUS
 769 LnPackageLengthWalk (
 770     ACPI_PARSE_OBJECT       *Op,
 771     UINT32                  Level,
 772     void                    *Context);
 773
 774 ACPI_STATUS
 775 LnInitLengthsWalk (
 776     ACPI_PARSE_OBJECT       *Op,
 777     UINT32                  Level,
 778     void                    *Context);
 779
 780 void
 781 CgGenerateAmlLengths (
 782     ACPI_PARSE_OBJECT       *Op);
 783
 784
 785 /*
 786  * aslmap - opcode mappings and reserved method names
 787  */
 788 ACPI_OBJECT_TYPE
 789 AslMapNamedOpcodeToDataType (
 790     UINT16                  Opcode);
 791
 792
 793 /*
 794  * aslpredef - ACPI predefined names support
 795  */
 796 BOOLEAN
 797 ApCheckForPredefinedMethod (
 798     ACPI_PARSE_OBJECT       *Op,
 799     ASL_METHOD_INFO         *MethodInfo);
 800
 801 void
 802 ApCheckPredefinedReturnValue (
 803     ACPI_PARSE_OBJECT       *Op,
 804     ASL_METHOD_INFO         *MethodInfo);
 805
 806 UINT32
 807 ApCheckForPredefinedName (
 808     ACPI_PARSE_OBJECT       *Op,
 809     char                    *Name);
 810
 811 void
 812 ApCheckForPredefinedObject (
 813     ACPI_PARSE_OBJECT       *Op,
 814     char                    *Name);
 815
 816 ACPI_STATUS
 817 ApCheckObjectType (
 818     const char              *PredefinedName,
 819     ACPI_PARSE_OBJECT       *Op,
 820     UINT32                  ExpectedBtypes,
 821     UINT32                  PackageIndex);
 822
 823 void
 824 ApDisplayReservedNames (
 825     void);
 826
 827
 828 /*
 829  * aslprepkg - ACPI predefined names support for packages
 830  */
 831 void
 832 ApCheckPackage (
 833     ACPI_PARSE_OBJECT           *ParentOp,
 834     const ACPI_PREDEFINED_INFO  *Predefined);
 835
 836
 837 /*
 838  * asltransform - parse tree transformations
 839  */
 840 ACPI_STATUS
 841 TrAmlTransformWalkBegin (
 842     ACPI_PARSE_OBJECT       *Op,
 843     UINT32                  Level,
 844     void                    *Context);
 845
 846 ACPI_STATUS
 847 TrAmlTransformWalkEnd (
 848     ACPI_PARSE_OBJECT       *Op,
 849     UINT32                  Level,
 850     void                    *Context);
 851
 852
 853 /*
 854  * aslexternal - External opcode support
 855  */
 856 ACPI_STATUS
 857 ExAmlExternalWalkBegin (
 858     ACPI_PARSE_OBJECT       *Op,
 859     UINT32                  Level,
 860     void                    *Context);
 861
 862 ACPI_STATUS
 863 ExAmlExternalWalkEnd (
 864     ACPI_PARSE_OBJECT       *Op,
 865     UINT32                  Level,
 866     void                    *Context);
 867
 868 void
 869 ExDoExternal (
 870     ACPI_PARSE_OBJECT       *Op);
 871
 872 /* Values for "Visitation" parameter above */
 873
 874 #define ASL_WALK_VISIT_DOWNWARD     0x01
 875 #define ASL_WALK_VISIT_UPWARD       0x02
 876 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 877
 878
 879 /*
 880  * aslparseop.c - Parse op create/allocate/cache
 881  */
 882 ACPI_PARSE_OBJECT *
 883 TrCreateOp (
 884     UINT32                  ParseOpcode,
 885     UINT32                  NumChildren,
 886     ...);
 887
 888 ACPI_PARSE_OBJECT *
 889 TrCreateLeafOp (
 890     UINT32                  ParseOpcode);
 891
 892 ACPI_PARSE_OBJECT *
 893 TrCreateNullTargetOp (
 894     void);
 895
 896 ACPI_PARSE_OBJECT *
 897 TrCreateAssignmentOp (
 898     ACPI_PARSE_OBJECT       *Target,
 899     ACPI_PARSE_OBJECT       *Source);
 900
 901 ACPI_PARSE_OBJECT *
 902 TrCreateTargetOp (
 903     ACPI_PARSE_OBJECT       *OriginalOp,
 904     ACPI_PARSE_OBJECT       *ParentOp);
 905
 906 ACPI_PARSE_OBJECT *
 907 TrCreateValuedLeafOp (
 908     UINT32                  ParseOpcode,
 909     UINT64                  Value);
 910
 911 ACPI_PARSE_OBJECT *
 912 TrCreateConstantLeafOp (
 913     UINT32                  ParseOpcode);
 914
 915 ACPI_PARSE_OBJECT *
 916 TrAllocateOp (
 917     UINT32                  ParseOpcode);
 918
 919 void
 920 TrPrintOpFlags (
 921     UINT32                  Flags,
 922     UINT32                  OutputLevel);
 923
 924
 925 /*
 926  * asltree.c - Parse tree management
 927  */
 928 void
 929 TrSetOpParent (
 930     ACPI_PARSE_OBJECT       *Op,
 931     ACPI_PARSE_OBJECT       *ParentOp);
 932
 933 ACPI_PARSE_OBJECT *
 934 TrSetOpIntegerValue (
 935     UINT32                  ParseOpcode,
 936     ACPI_PARSE_OBJECT       *Op);
 937
 938 void
 939 TrSetOpEndLineNumber (
 940     ACPI_PARSE_OBJECT       *Op);
 941
 942 void
 943 TrSetOpCurrentFilename (
 944     ACPI_PARSE_OBJECT       *Op);
 945
 946 void
 947 TrSetOpIntegerWidth (
 948     ACPI_PARSE_OBJECT       *TableSignature,
 949     ACPI_PARSE_OBJECT       *Revision);
 950
 951 ACPI_PARSE_OBJECT *
 952 TrLinkOpChildren (
 953     ACPI_PARSE_OBJECT       *Op,
 954     UINT32                  NumChildren,
 955     ...);
 956
 957 ACPI_PARSE_OBJECT *
 958 TrLinkPeerOp (
 959     ACPI_PARSE_OBJECT       *Op1,
 960     ACPI_PARSE_OBJECT       *Op2);
 961
 962 ACPI_PARSE_OBJECT *
 963 TrLinkChildOp (
 964     ACPI_PARSE_OBJECT       *Op1,
 965     ACPI_PARSE_OBJECT       *Op2);
 966
 967 ACPI_PARSE_OBJECT *
 968 TrSetOpFlags (
 969     ACPI_PARSE_OBJECT       *Op,
 970     UINT32                  Flags);
 971
 972 ACPI_PARSE_OBJECT *
 973 TrSetOpAmlLength (
 974     ACPI_PARSE_OBJECT       *Op,
 975     UINT32                  Length);
 976
 977 ACPI_PARSE_OBJECT *
 978 TrLinkPeerOps (
 979     UINT32                  NumPeers,
 980     ...);
 981
 982 ACPI_STATUS
 983 TrWalkParseTree (
 984     ACPI_PARSE_OBJECT       *Op,
 985     UINT32                  Visitation,
 986     ASL_WALK_CALLBACK       DescendingCallback,
 987     ASL_WALK_CALLBACK       AscendingCallback,
 988     void                    *Context);
 989
 990
 991 /*
 992  * aslfiles - File I/O support
 993  */
 994 void
 995 FlAddIncludeDirectory (
 996     char                    *Dir);
 997
 998 char *
 999 FlMergePathnames (
1000     char                    *PrefixDir,
1001     char                    *FilePathname);
1002
1003 void
1004 FlOpenIncludeFile (
1005     ACPI_PARSE_OBJECT       *Op);
1006
1007 void
1008 FlFileError (
1009     UINT32                  FileId,
1010     UINT8                   ErrorId);
1011
1012 UINT32
1013 FlGetFileSize (
1014     UINT32                  FileId);
1015
1016 ACPI_STATUS
1017 FlReadFile (
1018     UINT32                  FileId,
1019     void                    *Buffer,
1020     UINT32                  Length);
1021
1022 void
1023 FlWriteFile (
1024     UINT32                  FileId,
1025     void                    *Buffer,
1026     UINT32                  Length);
1027
1028 void
1029 FlSeekFile (
1030     UINT32                  FileId,
1031     long                    Offset);
1032
1033 void
1034 FlCloseFile (
1035     UINT32                  FileId);
1036
1037 void
1038 FlPrintFile (
1039     UINT32                  FileId,
1040     char                    *Format,
1041     ...);
1042
1043 void
1044 FlDeleteFile (
1045     UINT32                  FileId);
1046
1047 void
1048 FlSetLineNumber (
1049     UINT32                  LineNumber);
1050
1051 void
1052 FlSetFilename (
1053     char                    *Filename);
1054
1055 ACPI_STATUS
1056 FlOpenInputFile (
1057     char                    *InputFilename);
1058
1059 ACPI_STATUS
1060 FlOpenAmlOutputFile (
1061     char                    *InputFilename);
1062
1063 ACPI_STATUS
1064 FlOpenMiscOutputFiles (
1065     char                    *InputFilename);
1066
1067 /*
1068  * aslhwmap - hardware map summary
1069  */
1070 void
1071 MpEmitMappingInfo (
1072     void);
1073
1074
1075 /*
1076  * asload - load namespace in prep for cross reference
1077  */
1078 ACPI_STATUS
1079 LdLoadNamespace (
1080     ACPI_PARSE_OBJECT       *RootOp);
1081
1082
1083 /*
1084  * asllookup - namespace lookup functions
1085  */
1086 void
1087 LkFindUnreferencedObjects (
1088     void);
1089
1090 /*
1091  * aslhelp - help screens
1092  */
1093 void
1094 Usage (
1095     void);
1096
1097 void
1098 AslFilenameHelp (
1099     void);
1100
1101 void
1102 AslDisassemblyHelp (
1103     void);
1104
1105
1106 /*
1107  * aslnamesp - namespace output file generation
1108  */
1109 ACPI_STATUS
1110 NsDisplayNamespace (
1111     void);
1112
1113 void
1114 NsSetupNamespaceListing (
1115     void                    *Handle);
1116
1117 /*
1118  * asloptions - command line processing
1119  */
1120 int
1121 AslCommandLine (
1122     int                     argc,
1123     char                    **argv);
1124
1125 /*
1126  * aslxref - namespace cross reference
1127  */
1128 ACPI_STATUS
1129 XfCrossReferenceNamespace (
1130     void);
1131
1132
1133 /*
1134  * aslxrefout
1135  */
1136 void
1137 OtPrintHeaders (
1138     char                    *Message);
1139
1140 void
1141 OtCreateXrefFile (
1142     void);
1143
1144 void
1145 OtXrefWalkPart1 (
1146     ACPI_PARSE_OBJECT       *Op,
1147     UINT32                  Level,
1148     ASL_METHOD_INFO         *MethodInfo);
1149
1150
1151 /*
1152  * aslutils - common compiler utilites
1153  */
1154 void
1155 DbgPrint (
1156     UINT32                  Type,
1157     char                    *Format,
1158     ...);
1159
1160 /* Type values for above */
1161
1162 #define ASL_DEBUG_OUTPUT    0
1163 #define ASL_PARSE_OUTPUT    1
1164 #define ASL_TREE_OUTPUT     2
1165
1166 UINT8
1167 UtIsBigEndianMachine (
1168     void);
1169
1170 BOOLEAN
1171 UtQueryForOverwrite (
1172     char                    *Pathname);
1173
1174 void
1175 UtDumpStringOp (
1176     ACPI_PARSE_OBJECT       *Op,
1177     UINT32                  Level);
1178
1179 void
1180 UtDumpIntegerOp (
1181     ACPI_PARSE_OBJECT       *Op,
1182     UINT32                  Level,
1183     UINT32                  IntegerLength);
1184
1185 void
1186 UtDumpBasicOp (
1187     ACPI_PARSE_OBJECT       *Op,
1188     UINT32                  Level);
1189
1190 void
1191 UtDisplaySupportedTables (
1192     void);
1193
1194 void
1195 UtDisplayConstantOpcodes (
1196     void);
1197
1198 UINT8
1199 UtBeginEvent (
1200     char                    *Name);
1201
1202 void
1203 UtEndEvent (
1204     UINT8                   Event);
1205
1206 void
1207 UtDisplaySummary (
1208     UINT32                  FileId);
1209
1210 void
1211 UtConvertByteToHex (
1212     UINT8                   RawByte,
1213     UINT8                   *Buffer);
1214
1215 void
1216 UtConvertByteToAsmHex (
1217     UINT8                   RawByte,
1218     UINT8                   *Buffer);
1219
1220 char *
1221 UtGetOpName (
1222     UINT32                  ParseOpcode);
1223
1224 void
1225 UtSetParseOpName (
1226     ACPI_PARSE_OBJECT       *Op);
1227
1228 ACPI_STATUS
1229 UtInternalizeName (
1230     char                    *ExternalName,
1231     char                    **ConvertedName);
1232
1233 void
1234 UtAttachNamepathToOwner (
1235     ACPI_PARSE_OBJECT       *Op,
1236     ACPI_PARSE_OBJECT       *NameNode);
1237
1238 ACPI_PARSE_OBJECT *
1239 UtCheckIntegerRange (
1240     ACPI_PARSE_OBJECT       *Op,
1241     UINT32                  LowValue,
1242     UINT32                  HighValue);
1243
1244 UINT64
1245 UtDoConstant (
1246     char                    *String);
1247
1248
1249 /*
1250  * asluuid - UUID support
1251  */
1252 ACPI_STATUS
1253 AuValidateUuid (
1254     char                    *InString);
1255
1256 ACPI_STATUS
1257 AuConvertUuidToString (
1258     char                    *UuIdBuffer,
1259     char                    *OutString);
1260
1261 /*
1262  * aslresource - Resource template generation utilities
1263  */
1264 void
1265 RsSmallAddressCheck (
1266     UINT8                   Type,
1267     UINT32                  Minimum,
1268     UINT32                  Maximum,
1269     UINT32                  Length,
1270     UINT32                  Alignment,
1271     ACPI_PARSE_OBJECT       *MinOp,
1272     ACPI_PARSE_OBJECT       *MaxOp,
1273     ACPI_PARSE_OBJECT       *LengthOp,
1274     ACPI_PARSE_OBJECT       *AlignOp,
1275     ACPI_PARSE_OBJECT       *Op);
1276
1277 void
1278 RsLargeAddressCheck (
1279     UINT64                  Minimum,
1280     UINT64                  Maximum,
1281     UINT64                  Length,
1282     UINT64                  Granularity,
1283     UINT8                   Flags,
1284     ACPI_PARSE_OBJECT       *MinOp,
1285     ACPI_PARSE_OBJECT       *MaxOp,
1286     ACPI_PARSE_OBJECT       *LengthOp,
1287     ACPI_PARSE_OBJECT       *GranOp,
1288     ACPI_PARSE_OBJECT       *Op);
1289
1290 UINT16
1291 RsGetStringDataLength (
1292     ACPI_PARSE_OBJECT       *InitializerOp);
1293
1294 ASL_RESOURCE_NODE *
1295 RsAllocateResourceNode (
1296     UINT32                  Size);
1297
1298 void
1299 RsCreateResourceField (
1300     ACPI_PARSE_OBJECT       *Op,
1301     char                    *Name,
1302     UINT32                  ByteOffset,
1303     UINT32                  BitOffset,
1304     UINT32                  BitLength);
1305
1306 void
1307 RsSetFlagBits (
1308     UINT8                   *Flags,
1309     ACPI_PARSE_OBJECT       *Op,
1310     UINT8                   Position,
1311     UINT8                   DefaultBit);
1312
1313 void
1314 RsSetFlagBits16 (
1315     UINT16                  *Flags,
1316     ACPI_PARSE_OBJECT       *Op,
1317     UINT8                   Position,
1318     UINT8                   DefaultBit);
1319
1320 ACPI_PARSE_OBJECT *
1321 RsCompleteNodeAndGetNext (
1322     ACPI_PARSE_OBJECT       *Op);
1323
1324 void
1325 RsCheckListForDuplicates (
1326     ACPI_PARSE_OBJECT       *Op);
1327
1328 ASL_RESOURCE_NODE *
1329 RsDoOneResourceDescriptor (
1330     ASL_RESOURCE_INFO       *Info,
1331     UINT8                   *State);
1332
1333 /* Values for State above */
1334
1335 #define ACPI_RSTATE_NORMAL              0
1336 #define ACPI_RSTATE_START_DEPENDENT     1
1337 #define ACPI_RSTATE_DEPENDENT_LIST      2
1338
1339 UINT32
1340 RsLinkDescriptorChain (
1341     ASL_RESOURCE_NODE       **PreviousRnode,
1342     ASL_RESOURCE_NODE       *Rnode);
1343
1344 void
1345 RsDoResourceTemplate (
1346     ACPI_PARSE_OBJECT       *Op);
1347
1348
1349 /*
1350  * aslrestype1 - Miscellaneous Small descriptors
1351  */
1352 ASL_RESOURCE_NODE *
1353 RsDoEndTagDescriptor (
1354     ASL_RESOURCE_INFO       *Info);
1355
1356 ASL_RESOURCE_NODE *
1357 RsDoEndDependentDescriptor (
1358     ASL_RESOURCE_INFO       *Info);
1359
1360 ASL_RESOURCE_NODE *
1361 RsDoMemory24Descriptor (
1362     ASL_RESOURCE_INFO       *Info);
1363
1364 ASL_RESOURCE_NODE *
1365 RsDoMemory32Descriptor (
1366     ASL_RESOURCE_INFO       *Info);
1367
1368 ASL_RESOURCE_NODE *
1369 RsDoMemory32FixedDescriptor (
1370     ASL_RESOURCE_INFO       *Info);
1371
1372 ASL_RESOURCE_NODE *
1373 RsDoStartDependentDescriptor (
1374     ASL_RESOURCE_INFO       *Info);
1375
1376 ASL_RESOURCE_NODE *
1377 RsDoStartDependentNoPriDescriptor (
1378     ASL_RESOURCE_INFO       *Info);
1379
1380 ASL_RESOURCE_NODE *
1381 RsDoVendorSmallDescriptor (
1382     ASL_RESOURCE_INFO       *Info);
1383
1384
1385 /*
1386  * aslrestype1i - I/O-related Small descriptors
1387  */
1388 ASL_RESOURCE_NODE *
1389 RsDoDmaDescriptor (
1390     ASL_RESOURCE_INFO       *Info);
1391
1392 ASL_RESOURCE_NODE *
1393 RsDoFixedDmaDescriptor (
1394     ASL_RESOURCE_INFO       *Info);
1395
1396 ASL_RESOURCE_NODE *
1397 RsDoFixedIoDescriptor (
1398     ASL_RESOURCE_INFO       *Info);
1399
1400 ASL_RESOURCE_NODE *
1401 RsDoIoDescriptor (
1402     ASL_RESOURCE_INFO       *Info);
1403
1404 ASL_RESOURCE_NODE *
1405 RsDoIrqDescriptor (
1406     ASL_RESOURCE_INFO       *Info);
1407
1408 ASL_RESOURCE_NODE *
1409 RsDoIrqNoFlagsDescriptor (
1410     ASL_RESOURCE_INFO       *Info);
1411
1412
1413 /*
1414  * aslrestype2 - Large resource descriptors
1415  */
1416 ASL_RESOURCE_NODE *
1417 RsDoInterruptDescriptor (
1418     ASL_RESOURCE_INFO       *Info);
1419
1420 ASL_RESOURCE_NODE *
1421 RsDoVendorLargeDescriptor (
1422     ASL_RESOURCE_INFO       *Info);
1423
1424 ASL_RESOURCE_NODE *
1425 RsDoGeneralRegisterDescriptor (
1426     ASL_RESOURCE_INFO       *Info);
1427
1428 ASL_RESOURCE_NODE *
1429 RsDoGpioIntDescriptor (
1430     ASL_RESOURCE_INFO       *Info);
1431
1432 ASL_RESOURCE_NODE *
1433 RsDoGpioIoDescriptor (
1434     ASL_RESOURCE_INFO       *Info);
1435
1436 ASL_RESOURCE_NODE *
1437 RsDoI2cSerialBusDescriptor (
1438     ASL_RESOURCE_INFO       *Info);
1439
1440 ASL_RESOURCE_NODE *
1441 RsDoSpiSerialBusDescriptor (
1442     ASL_RESOURCE_INFO       *Info);
1443
1444 ASL_RESOURCE_NODE *
1445 RsDoUartSerialBusDescriptor (
1446     ASL_RESOURCE_INFO       *Info);
1447
1448 ASL_RESOURCE_NODE *
1449 RsDoPinFunctionDescriptor (
1450     ASL_RESOURCE_INFO       *Info);
1451
1452 ASL_RESOURCE_NODE *
1453 RsDoPinConfigDescriptor (
1454     ASL_RESOURCE_INFO       *Info);
1455
1456 ASL_RESOURCE_NODE *
1457 RsDoPinGroupDescriptor (
1458     ASL_RESOURCE_INFO       *Info);
1459
1460 ASL_RESOURCE_NODE *
1461 RsDoPinGroupFunctionDescriptor (
1462     ASL_RESOURCE_INFO       *Info);
1463
1464 ASL_RESOURCE_NODE *
1465 RsDoPinGroupConfigDescriptor (
1466     ASL_RESOURCE_INFO       *Info);
1467
1468 /*
1469  * aslrestype2d - DWord address descriptors
1470  */
1471 ASL_RESOURCE_NODE *
1472 RsDoDwordIoDescriptor (
1473     ASL_RESOURCE_INFO       *Info);
1474
1475 ASL_RESOURCE_NODE *
1476 RsDoDwordMemoryDescriptor (
1477     ASL_RESOURCE_INFO       *Info);
1478
1479 ASL_RESOURCE_NODE *
1480 RsDoDwordSpaceDescriptor (
1481     ASL_RESOURCE_INFO       *Info);
1482
1483
1484 /*
1485  * aslrestype2e - Extended address descriptors
1486  */
1487 ASL_RESOURCE_NODE *
1488 RsDoExtendedIoDescriptor (
1489     ASL_RESOURCE_INFO       *Info);
1490
1491 ASL_RESOURCE_NODE *
1492 RsDoExtendedMemoryDescriptor (
1493     ASL_RESOURCE_INFO       *Info);
1494
1495 ASL_RESOURCE_NODE *
1496 RsDoExtendedSpaceDescriptor (
1497     ASL_RESOURCE_INFO       *Info);
1498
1499
1500 /*
1501  * aslrestype2q - QWord address descriptors
1502  */
1503 ASL_RESOURCE_NODE *
1504 RsDoQwordIoDescriptor (
1505     ASL_RESOURCE_INFO       *Info);
1506
1507 ASL_RESOURCE_NODE *
1508 RsDoQwordMemoryDescriptor (
1509     ASL_RESOURCE_INFO       *Info);
1510
1511 ASL_RESOURCE_NODE *
1512 RsDoQwordSpaceDescriptor (
1513     ASL_RESOURCE_INFO       *Info);
1514
1515
1516 /*
1517  * aslrestype2w - Word address descriptors
1518  */
1519 ASL_RESOURCE_NODE *
1520 RsDoWordIoDescriptor (
1521     ASL_RESOURCE_INFO       *Info);
1522
1523 ASL_RESOURCE_NODE *
1524 RsDoWordSpaceDescriptor (
1525     ASL_RESOURCE_INFO       *Info);
1526
1527 ASL_RESOURCE_NODE *
1528 RsDoWordBusNumberDescriptor (
1529     ASL_RESOURCE_INFO       *Info);
1530
1531
1532 /*
1533  * Entry to data table compiler subsystem
1534  */
1535 ACPI_STATUS
1536 DtDoCompile(
1537     void);
1538
1539 ACPI_STATUS
1540 DtCreateTemplates (
1541     char                    **argv);
1542
1543
1544 /*
1545  * ASL/ASL+ converter debug
1546  */
1547 void
1548 CvDbgPrint (
1549     char                    *Fmt,
1550     ...);
1551
1552
1553 #endif /*  __ASLCOMPILER_H */