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