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  * Copyright (C) 2000 - 2014, Intel Corp.
   9  * All rights reserved.
  10  *
  11  * Redistribution and use in source and binary forms, with or without
  12  * modification, are permitted provided that the following conditions
  13  * are met:
  14  * 1. Redistributions of source code must retain the above copyright
  15  *    notice, this list of conditions, and the following disclaimer,
  16  *    without modification.
  17  * 2. Redistributions in binary form must reproduce at minimum a disclaimer
  18  *    substantially similar to the "NO WARRANTY" disclaimer below
  19  *    ("Disclaimer") and any redistribution must be conditioned upon
  20  *    including a substantially similar Disclaimer requirement for further
  21  *    binary redistribution.
  22  * 3. Neither the names of the above-listed copyright holders nor the names
  23  *    of any contributors may be used to endorse or promote products derived
  24  *    from this software without specific prior written permission.
  25  *
  26  * Alternatively, this software may be distributed under the terms of the
  27  * GNU General Public License ("GPL") version 2 as published by the Free
  28  * Software Foundation.
  29  *
  30  * NO WARRANTY
  31  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  32  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  33  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
  34  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  35  * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  36  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  37  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  38  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  39  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
  40  * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  41  * POSSIBILITY OF SUCH DAMAGES.
  42  */
  43
  44
  45 #ifndef __ASLCOMPILER_H
  46 #define __ASLCOMPILER_H
  47
  48 #include "acpi.h"
  49 #include "accommon.h"
  50 #include "amlresrc.h"
  51 #include "acdebug.h"
  52
  53 /* Microsoft-specific */
  54
  55 #if (defined WIN32 || defined WIN64)
  56
  57 /* warn : used #pragma pack */
  58 #pragma warning(disable:4103)
  59
  60 /* warn : named type definition in parentheses */
  61 #pragma warning(disable:4115)
  62 #endif
  63
  64 #include <stdio.h>
  65 #include <stdlib.h>
  66 #include <stdarg.h>
  67 #include <string.h>
  68 #include <errno.h>
  69 #include <ctype.h>
  70
  71 /* Compiler headers */
  72
  73 #include "asldefine.h"
  74 #include "asltypes.h"
  75 #include "aslmessages.h"
  76 #include "aslglobal.h"
  77 #include "preprocess.h"
  78
  79
  80 /*******************************************************************************
  81  *
  82  * Compiler prototypes
  83  *
  84  ******************************************************************************/
  85
  86 /*
  87  * Main ASL parser - generated from flex/bison, lex/yacc, etc.
  88  */
  89 ACPI_PARSE_OBJECT *
  90 AslDoError (
  91     void);
  92
  93 int
  94 AslCompilerlex(
  95     void);
  96
  97 void
  98 AslResetCurrentLineBuffer (
  99     void);
 100
 101 void
 102 AslInsertLineBuffer (
 103     int                     SourceChar);
 104
 105 int
 106 AslPopInputFileStack (
 107     void);
 108
 109 void
 110 AslPushInputFileStack (
 111     FILE                    *InputFile,
 112     char                    *Filename);
 113
 114 /*
 115  * aslstartup - entered from main()
 116  */
 117 void
 118 AslInitializeGlobals (
 119     void);
 120
 121 typedef
 122 ACPI_STATUS (*ASL_PATHNAME_CALLBACK) (
 123     char *);
 124
 125 ACPI_STATUS
 126 AslDoOneFile (
 127     char                    *Filename);
 128
 129 ACPI_STATUS
 130 AslCheckForErrorExit (
 131     void);
 132
 133
 134 /*
 135  * aslcompile - compile mainline
 136  */
 137 void
 138 AslCompilerSignon (
 139     UINT32                  FileId);
 140
 141 void
 142 AslCompilerFileHeader (
 143     UINT32                  FileId);
 144
 145 int
 146 CmDoCompile (
 147     void);
 148
 149 void
 150 CmDoOutputFiles (
 151     void);
 152
 153 void
 154 CmCleanupAndExit (
 155     void);
 156
 157 ACPI_STATUS
 158 FlCheckForAcpiTable (
 159     FILE                    *Handle);
 160
 161 ACPI_STATUS
 162 FlCheckForAscii (
 163     FILE                    *Handle,
 164     char                    *Filename,
 165     BOOLEAN                 DisplayErrors);
 166
 167
 168 /*
 169  * aslwalks - semantic analysis and parse tree walks
 170  */
 171 ACPI_STATUS
 172 AnOtherSemanticAnalysisWalkBegin (
 173     ACPI_PARSE_OBJECT       *Op,
 174     UINT32                  Level,
 175     void                    *Context);
 176
 177 ACPI_STATUS
 178 AnOtherSemanticAnalysisWalkEnd (
 179     ACPI_PARSE_OBJECT       *Op,
 180     UINT32                  Level,
 181     void                    *Context);
 182
 183 ACPI_STATUS
 184 AnOperandTypecheckWalkEnd (
 185     ACPI_PARSE_OBJECT       *Op,
 186     UINT32                  Level,
 187     void                    *Context);
 188
 189 ACPI_STATUS
 190 AnMethodTypingWalkEnd (
 191     ACPI_PARSE_OBJECT       *Op,
 192     UINT32                  Level,
 193     void                    *Context);
 194
 195
 196 /*
 197  * aslmethod - Control method analysis walk
 198  */
 199 ACPI_STATUS
 200 MtMethodAnalysisWalkBegin (
 201     ACPI_PARSE_OBJECT       *Op,
 202     UINT32                  Level,
 203     void                    *Context);
 204
 205 ACPI_STATUS
 206 MtMethodAnalysisWalkEnd (
 207     ACPI_PARSE_OBJECT       *Op,
 208     UINT32                  Level,
 209     void                    *Context);
 210
 211
 212 /*
 213  * aslbtypes - bitfield data types
 214  */
 215 UINT32
 216 AnMapObjTypeToBtype (
 217     ACPI_PARSE_OBJECT       *Op);
 218
 219 UINT32
 220 AnMapArgTypeToBtype (
 221     UINT32                  ArgType);
 222
 223 UINT32
 224 AnGetBtype (
 225     ACPI_PARSE_OBJECT       *Op);
 226
 227 void
 228 AnFormatBtype (
 229     char                    *Buffer,
 230     UINT32                  Btype);
 231
 232
 233 /*
 234  * aslanalyze - Support functions for parse tree walks
 235  */
 236 void
 237 AnCheckId (
 238     ACPI_PARSE_OBJECT       *Op,
 239     ACPI_NAME               Type);
 240
 241 /* Values for Type argument above */
 242
 243 #define ASL_TYPE_HID        0
 244 #define ASL_TYPE_CID        1
 245
 246 BOOLEAN
 247 AnIsInternalMethod (
 248     ACPI_PARSE_OBJECT       *Op);
 249
 250 UINT32
 251 AnGetInternalMethodReturnType (
 252     ACPI_PARSE_OBJECT       *Op);
 253
 254 BOOLEAN
 255 AnLastStatementIsReturn (
 256     ACPI_PARSE_OBJECT       *Op);
 257
 258 void
 259 AnCheckMethodReturnValue (
 260     ACPI_PARSE_OBJECT       *Op,
 261     const ACPI_OPCODE_INFO  *OpInfo,
 262     ACPI_PARSE_OBJECT       *ArgOp,
 263     UINT32                  RequiredBtypes,
 264     UINT32                  ThisNodeBtype);
 265
 266 BOOLEAN
 267 AnIsResultUsed (
 268     ACPI_PARSE_OBJECT       *Op);
 269
 270 void
 271 ApCheckForGpeNameConflict (
 272     ACPI_PARSE_OBJECT       *Op);
 273
 274 void
 275 ApCheckRegMethod (
 276     ACPI_PARSE_OBJECT       *Op);
 277
 278
 279 /*
 280  * aslerror - error handling/reporting
 281  */
 282 void
 283 AslAbort (
 284     void);
 285
 286 void
 287 AslError (
 288     UINT8                   Level,
 289     UINT16                  MessageId,
 290     ACPI_PARSE_OBJECT       *Op,
 291     char                    *ExtraMessage);
 292
 293 ACPI_STATUS
 294 AslDisableException (
 295     char                    *MessageIdString);
 296
 297 BOOLEAN
 298 AslIsExceptionDisabled (
 299     UINT8                   Level,
 300     UINT16                  MessageId);
 301
 302 void
 303 AslCoreSubsystemError (
 304     ACPI_PARSE_OBJECT       *Op,
 305     ACPI_STATUS             Status,
 306     char                    *ExtraMessage,
 307     BOOLEAN                 Abort);
 308
 309 int
 310 AslCompilererror(
 311     const char              *s);
 312
 313 void
 314 AslCommonError (
 315     UINT8                   Level,
 316     UINT16                  MessageId,
 317     UINT32                  CurrentLineNumber,
 318     UINT32                  LogicalLineNumber,
 319     UINT32                  LogicalByteOffset,
 320     UINT32                  Column,
 321     char                    *Filename,
 322     char                    *ExtraMessage);
 323
 324 void
 325 AslCommonError2 (
 326     UINT8                   Level,
 327     UINT16                  MessageId,
 328     UINT32                  LineNumber,
 329     UINT32                  Column,
 330     char                    *SourceLine,
 331     char                    *Filename,
 332     char                    *ExtraMessage);
 333
 334 void
 335 AePrintException (
 336     UINT32                  FileId,
 337     ASL_ERROR_MSG           *Enode,
 338     char                    *Header);
 339
 340 void
 341 AePrintErrorLog (
 342     UINT32                  FileId);
 343
 344 void
 345 AeClearErrorLog (
 346     void);
 347
 348
 349 /*
 350  * asllisting - generate all "listing" type files
 351  */
 352 void
 353 LsDoListings (
 354     void);
 355
 356 void
 357 LsWriteNodeToAsmListing (
 358     ACPI_PARSE_OBJECT       *Op);
 359
 360 void
 361 LsWriteNode (
 362     ACPI_PARSE_OBJECT       *Op,
 363     UINT32                  FileId);
 364
 365 void
 366 LsDumpParseTree (
 367     void);
 368
 369
 370 /*
 371  * asllistsup - Listing file support utilities
 372  */
 373 void
 374 LsDumpAscii (
 375     UINT32                  FileId,
 376     UINT32                  Count,
 377     UINT8                   *Buffer);
 378
 379 void
 380 LsDumpAsciiInComment (
 381     UINT32                  FileId,
 382     UINT32                  Count,
 383     UINT8                   *Buffer);
 384
 385 void
 386 LsCheckException (
 387     UINT32                  LineNumber,
 388     UINT32                  FileId);
 389
 390 void
 391 LsFlushListingBuffer (
 392     UINT32                  FileId);
 393
 394 void
 395 LsWriteListingHexBytes (
 396     UINT8                   *Buffer,
 397     UINT32                  Length,
 398     UINT32                  FileId);
 399
 400 void
 401 LsWriteSourceLines (
 402     UINT32                  ToLineNumber,
 403     UINT32                  ToLogicalLineNumber,
 404     UINT32                  FileId);
 405
 406 UINT32
 407 LsWriteOneSourceLine (
 408     UINT32                  FileId);
 409
 410 void
 411 LsPushNode (
 412     char                    *Filename);
 413
 414 ASL_LISTING_NODE *
 415 LsPopNode (
 416     void);
 417
 418
 419 /*
 420  * aslhex - generate all "hex" output files (C, ASM, ASL)
 421  */
 422 void
 423 HxDoHexOutput (
 424     void);
 425
 426
 427 /*
 428  * aslfold - constant folding
 429  */
 430 ACPI_STATUS
 431 OpcAmlConstantWalk (
 432     ACPI_PARSE_OBJECT       *Op,
 433     UINT32                  Level,
 434     void                    *Context);
 435
 436
 437 /*
 438  * aslmessages - exception strings
 439  */
 440 const char *
 441 AeDecodeMessageId (
 442     UINT16                  MessageId);
 443
 444 const char *
 445 AeDecodeExceptionLevel (
 446     UINT8                   Level);
 447
 448 UINT16
 449 AeBuildFullExceptionCode (
 450     UINT8                   Level,
 451     UINT16                  MessageId);
 452
 453 /*
 454  * asloffset - generate C offset file for BIOS support
 455  */
 456 ACPI_STATUS
 457 LsAmlOffsetWalk (
 458     ACPI_PARSE_OBJECT       *Op,
 459     UINT32                  Level,
 460     void                    *Context);
 461
 462 void
 463 LsDoOffsetTableHeader (
 464     UINT32                  FileId);
 465
 466 void
 467 LsDoOffsetTableFooter (
 468     UINT32                  FileId);
 469
 470
 471 /*
 472  * aslopcodes - generate AML opcodes
 473  */
 474 ACPI_STATUS
 475 OpcAmlOpcodeWalk (
 476     ACPI_PARSE_OBJECT       *Op,
 477     UINT32                  Level,
 478     void                    *Context);
 479
 480 ACPI_STATUS
 481 OpcAmlOpcodeUpdateWalk (
 482     ACPI_PARSE_OBJECT       *Op,
 483     UINT32                  Level,
 484     void                    *Context);
 485
 486 void
 487 OpcGenerateAmlOpcode (
 488     ACPI_PARSE_OBJECT       *Op);
 489
 490 UINT32
 491 OpcSetOptimalIntegerSize (
 492     ACPI_PARSE_OBJECT       *Op);
 493
 494 void
 495 OpcGetIntegerWidth (
 496     ACPI_PARSE_OBJECT       *Op);
 497
 498
 499 /*
 500  * asloperands - generate AML operands for the AML opcodes
 501  */
 502 ACPI_PARSE_OBJECT  *
 503 UtGetArg (
 504     ACPI_PARSE_OBJECT       *Op,
 505     UINT32                  Argn);
 506
 507 void
 508 OpnGenerateAmlOperands (
 509     ACPI_PARSE_OBJECT       *Op);
 510
 511 void
 512 OpnDoPackage (
 513     ACPI_PARSE_OBJECT       *Op);
 514
 515
 516 /*
 517  * aslopt - optmization
 518  */
 519 void
 520 OptOptimizeNamePath (
 521     ACPI_PARSE_OBJECT       *Op,
 522     UINT32                  Flags,
 523     ACPI_WALK_STATE         *WalkState,
 524     char                    *AmlNameString,
 525     ACPI_NAMESPACE_NODE     *TargetNode);
 526
 527
 528 /*
 529  * aslcodegen - code generation
 530  */
 531 void
 532 CgGenerateAmlOutput (
 533     void);
 534
 535
 536 /*
 537  * aslfile
 538  */
 539 void
 540 FlOpenFile (
 541     UINT32                  FileId,
 542     char                    *Filename,
 543     char                    *Mode);
 544
 545
 546 /*
 547  * asllength - calculate/adjust AML package lengths
 548  */
 549 ACPI_STATUS
 550 LnPackageLengthWalk (
 551     ACPI_PARSE_OBJECT       *Op,
 552     UINT32                  Level,
 553     void                    *Context);
 554
 555 ACPI_STATUS
 556 LnInitLengthsWalk (
 557     ACPI_PARSE_OBJECT       *Op,
 558     UINT32                  Level,
 559     void                    *Context);
 560
 561 void
 562 CgGenerateAmlLengths (
 563     ACPI_PARSE_OBJECT       *Op);
 564
 565
 566 /*
 567  * aslmap - opcode mappings and reserved method names
 568  */
 569 ACPI_OBJECT_TYPE
 570 AslMapNamedOpcodeToDataType (
 571     UINT16                  Opcode);
 572
 573
 574 /*
 575  * aslpredef - ACPI predefined names support
 576  */
 577 BOOLEAN
 578 ApCheckForPredefinedMethod (
 579     ACPI_PARSE_OBJECT       *Op,
 580     ASL_METHOD_INFO         *MethodInfo);
 581
 582 void
 583 ApCheckPredefinedReturnValue (
 584     ACPI_PARSE_OBJECT       *Op,
 585     ASL_METHOD_INFO         *MethodInfo);
 586
 587 UINT32
 588 ApCheckForPredefinedName (
 589     ACPI_PARSE_OBJECT       *Op,
 590     char                    *Name);
 591
 592 void
 593 ApCheckForPredefinedObject (
 594     ACPI_PARSE_OBJECT       *Op,
 595     char                    *Name);
 596
 597 ACPI_STATUS
 598 ApCheckObjectType (
 599     const char              *PredefinedName,
 600     ACPI_PARSE_OBJECT       *Op,
 601     UINT32                  ExpectedBtypes,
 602     UINT32                  PackageIndex);
 603
 604 void
 605 ApDisplayReservedNames (
 606     void);
 607
 608
 609 /*
 610  * aslprepkg - ACPI predefined names support for packages
 611  */
 612 void
 613 ApCheckPackage (
 614     ACPI_PARSE_OBJECT           *ParentOp,
 615     const ACPI_PREDEFINED_INFO  *Predefined);
 616
 617
 618 /*
 619  * asltransform - parse tree transformations
 620  */
 621 ACPI_STATUS
 622 TrAmlTransformWalk (
 623     ACPI_PARSE_OBJECT       *Op,
 624     UINT32                  Level,
 625     void                    *Context);
 626
 627
 628 /*
 629  * asltree - parse tree support
 630  */
 631 ACPI_STATUS
 632 TrWalkParseTree (
 633     ACPI_PARSE_OBJECT       *Op,
 634     UINT32                  Visitation,
 635     ASL_WALK_CALLBACK       DescendingCallback,
 636     ASL_WALK_CALLBACK       AscendingCallback,
 637     void                    *Context);
 638
 639 /* Values for "Visitation" parameter above */
 640
 641 #define ASL_WALK_VISIT_DOWNWARD     0x01
 642 #define ASL_WALK_VISIT_UPWARD       0x02
 643 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 644
 645
 646 ACPI_PARSE_OBJECT *
 647 TrAllocateNode (
 648     UINT32                  ParseOpcode);
 649
 650 void
 651 TrReleaseNode (
 652     ACPI_PARSE_OBJECT       *Op);
 653
 654 ACPI_PARSE_OBJECT *
 655 TrUpdateNode (
 656     UINT32                  ParseOpcode,
 657     ACPI_PARSE_OBJECT       *Op);
 658
 659 ACPI_PARSE_OBJECT *
 660 TrCreateNode (
 661     UINT32                  ParseOpcode,
 662     UINT32                  NumChildren,
 663     ...);
 664
 665 ACPI_PARSE_OBJECT *
 666 TrCreateLeafNode (
 667     UINT32                  ParseOpcode);
 668
 669 ACPI_PARSE_OBJECT *
 670 TrCreateValuedLeafNode (
 671     UINT32                  ParseOpcode,
 672     UINT64                  Value);
 673
 674 ACPI_PARSE_OBJECT *
 675 TrCreateConstantLeafNode (
 676     UINT32                  ParseOpcode);
 677
 678 ACPI_PARSE_OBJECT *
 679 TrLinkChildren (
 680     ACPI_PARSE_OBJECT       *Op,
 681     UINT32                  NumChildren,
 682     ...);
 683
 684 void
 685 TrSetEndLineNumber (
 686     ACPI_PARSE_OBJECT       *Op);
 687
 688 void
 689 TrWalkTree (
 690     void);
 691
 692 ACPI_PARSE_OBJECT *
 693 TrLinkPeerNode (
 694     ACPI_PARSE_OBJECT       *Op1,
 695     ACPI_PARSE_OBJECT       *Op2);
 696
 697 ACPI_PARSE_OBJECT *
 698 TrLinkChildNode (
 699     ACPI_PARSE_OBJECT       *Op1,
 700     ACPI_PARSE_OBJECT       *Op2);
 701
 702 ACPI_PARSE_OBJECT *
 703 TrSetNodeFlags (
 704     ACPI_PARSE_OBJECT       *Op,
 705     UINT32                  Flags);
 706
 707 ACPI_PARSE_OBJECT *
 708 TrSetNodeAmlLength (
 709     ACPI_PARSE_OBJECT       *Op,
 710     UINT32                  Length);
 711
 712 ACPI_PARSE_OBJECT *
 713 TrLinkPeerNodes (
 714     UINT32                  NumPeers,
 715     ...);
 716
 717
 718 /*
 719  * aslfiles - File I/O support
 720  */
 721 void
 722 FlAddIncludeDirectory (
 723     char                    *Dir);
 724
 725 char *
 726 FlMergePathnames (
 727     char                    *PrefixDir,
 728     char                    *FilePathname);
 729
 730 void
 731 FlOpenIncludeFile (
 732     ACPI_PARSE_OBJECT       *Op);
 733
 734 void
 735 FlFileError (
 736     UINT32                  FileId,
 737     UINT8                   ErrorId);
 738
 739 UINT32
 740 FlGetFileSize (
 741     UINT32                  FileId);
 742
 743 ACPI_STATUS
 744 FlReadFile (
 745     UINT32                  FileId,
 746     void                    *Buffer,
 747     UINT32                  Length);
 748
 749 void
 750 FlWriteFile (
 751     UINT32                  FileId,
 752     void                    *Buffer,
 753     UINT32                  Length);
 754
 755 void
 756 FlSeekFile (
 757     UINT32                  FileId,
 758     long                    Offset);
 759
 760 void
 761 FlCloseFile (
 762     UINT32                  FileId);
 763
 764 void
 765 FlPrintFile (
 766     UINT32                  FileId,
 767     char                    *Format,
 768     ...);
 769
 770 void
 771 FlDeleteFile (
 772     UINT32                  FileId);
 773
 774 void
 775 FlSetLineNumber (
 776     UINT32                  LineNumber);
 777
 778 void
 779 FlSetFilename (
 780     char                    *Filename);
 781
 782 ACPI_STATUS
 783 FlOpenInputFile (
 784     char                    *InputFilename);
 785
 786 ACPI_STATUS
 787 FlOpenAmlOutputFile (
 788     char                    *InputFilename);
 789
 790 ACPI_STATUS
 791 FlOpenMiscOutputFiles (
 792     char                    *InputFilename);
 793
 794
 795 /*
 796  * asload - load namespace in prep for cross reference
 797  */
 798 ACPI_STATUS
 799 LdLoadNamespace (
 800     ACPI_PARSE_OBJECT       *RootOp);
 801
 802
 803 /*
 804  * asllookup - namespace lookup functions
 805  */
 806 void
 807 LkFindUnreferencedObjects (
 808     void);
 809
 810 /*
 811  * aslmain - startup
 812  */
 813 void
 814 Usage (
 815     void);
 816
 817 void
 818 AslFilenameHelp (
 819     void);
 820
 821
 822 /*
 823  * aslnamesp - namespace output file generation
 824  */
 825 ACPI_STATUS
 826 NsDisplayNamespace (
 827     void);
 828
 829 void
 830 NsSetupNamespaceListing (
 831     void                    *Handle);
 832
 833 /*
 834  * asloptions - command line processing
 835  */
 836 int
 837 AslCommandLine (
 838     int                     argc,
 839     char                    **argv);
 840
 841 /*
 842  * aslxref - namespace cross reference
 843  */
 844 ACPI_STATUS
 845 XfCrossReferenceNamespace (
 846     void);
 847
 848
 849 /*
 850  * aslutils - common compiler utilites
 851  */
 852 void
 853 DbgPrint (
 854     UINT32                  Type,
 855     char                    *Format,
 856     ...);
 857
 858 /* Type values for above */
 859
 860 #define ASL_DEBUG_OUTPUT    0
 861 #define ASL_PARSE_OUTPUT    1
 862 #define ASL_TREE_OUTPUT     2
 863
 864 void
 865 UtDisplaySupportedTables (
 866     void);
 867
 868 void
 869 UtDisplayConstantOpcodes (
 870     void);
 871
 872 UINT8
 873 UtBeginEvent (
 874     char                    *Name);
 875
 876 void
 877 UtEndEvent (
 878     UINT8                   Event);
 879
 880 void *
 881 UtLocalCalloc (
 882     UINT32                  Size);
 883
 884 void
 885 UtPrintFormattedName (
 886     UINT16                  ParseOpcode,
 887     UINT32                  Level);
 888
 889 void
 890 UtDisplaySummary (
 891     UINT32                  FileId);
 892
 893 UINT8
 894 UtHexCharToValue (
 895     int                     HexChar);
 896
 897 void
 898 UtConvertByteToHex (
 899     UINT8                   RawByte,
 900     UINT8                   *Buffer);
 901
 902 void
 903 UtConvertByteToAsmHex (
 904     UINT8                   RawByte,
 905     UINT8                   *Buffer);
 906
 907 char *
 908 UtGetOpName (
 909     UINT32                  ParseOpcode);
 910
 911 void
 912 UtSetParseOpName (
 913     ACPI_PARSE_OBJECT       *Op);
 914
 915 char *
 916 UtGetStringBuffer (
 917     UINT32                  Length);
 918
 919 void
 920 UtExpandLineBuffers (
 921     void);
 922
 923 ACPI_STATUS
 924 UtInternalizeName (
 925     char                    *ExternalName,
 926     char                    **ConvertedName);
 927
 928 void
 929 UtAttachNamepathToOwner (
 930     ACPI_PARSE_OBJECT       *Op,
 931     ACPI_PARSE_OBJECT       *NameNode);
 932
 933 ACPI_PARSE_OBJECT *
 934 UtCheckIntegerRange (
 935     ACPI_PARSE_OBJECT       *Op,
 936     UINT32                  LowValue,
 937     UINT32                  HighValue);
 938
 939 UINT64
 940 UtDoConstant (
 941     char                    *String);
 942
 943 ACPI_STATUS
 944 UtStrtoul64 (
 945     char                    *String,
 946     UINT32                  Base,
 947     UINT64                  *RetInteger);
 948
 949
 950 /*
 951  * asluuid - UUID support
 952  */
 953 ACPI_STATUS
 954 AuValidateUuid (
 955     char                    *InString);
 956
 957 ACPI_STATUS
 958 AuConvertStringToUuid (
 959     char                    *InString,
 960     char                    *UuIdBuffer);
 961
 962 ACPI_STATUS
 963 AuConvertUuidToString (
 964     char                    *UuIdBuffer,
 965     char                    *OutString);
 966
 967 /*
 968  * aslresource - Resource template generation utilities
 969  */
 970 void
 971 RsSmallAddressCheck (
 972     UINT8                   Type,
 973     UINT32                  Minimum,
 974     UINT32                  Maximum,
 975     UINT32                  Length,
 976     UINT32                  Alignment,
 977     ACPI_PARSE_OBJECT       *MinOp,
 978     ACPI_PARSE_OBJECT       *MaxOp,
 979     ACPI_PARSE_OBJECT       *LengthOp,
 980     ACPI_PARSE_OBJECT       *AlignOp,
 981     ACPI_PARSE_OBJECT       *Op);
 982
 983 void
 984 RsLargeAddressCheck (
 985     UINT64                  Minimum,
 986     UINT64                  Maximum,
 987     UINT64                  Length,
 988     UINT64                  Granularity,
 989     UINT8                   Flags,
 990     ACPI_PARSE_OBJECT       *MinOp,
 991     ACPI_PARSE_OBJECT       *MaxOp,
 992     ACPI_PARSE_OBJECT       *LengthOp,
 993     ACPI_PARSE_OBJECT       *GranOp,
 994     ACPI_PARSE_OBJECT       *Op);
 995
 996 UINT16
 997 RsGetStringDataLength (
 998     ACPI_PARSE_OBJECT       *InitializerOp);
 999
1000 ASL_RESOURCE_NODE *
1001 RsAllocateResourceNode (
1002     UINT32                  Size);
1003
1004 void
1005 RsCreateResourceField (
1006     ACPI_PARSE_OBJECT       *Op,
1007     char                    *Name,
1008     UINT32                  ByteOffset,
1009     UINT32                  BitOffset,
1010     UINT32                  BitLength);
1011
1012 void
1013 RsSetFlagBits (
1014     UINT8                   *Flags,
1015     ACPI_PARSE_OBJECT       *Op,
1016     UINT8                   Position,
1017     UINT8                   DefaultBit);
1018
1019 void
1020 RsSetFlagBits16 (
1021     UINT16                  *Flags,
1022     ACPI_PARSE_OBJECT       *Op,
1023     UINT8                   Position,
1024     UINT8                   DefaultBit);
1025
1026 ACPI_PARSE_OBJECT *
1027 RsCompleteNodeAndGetNext (
1028     ACPI_PARSE_OBJECT       *Op);
1029
1030 void
1031 RsCheckListForDuplicates (
1032     ACPI_PARSE_OBJECT       *Op);
1033
1034 ASL_RESOURCE_NODE *
1035 RsDoOneResourceDescriptor (
1036     ACPI_PARSE_OBJECT       *DescriptorTypeOp,
1037     UINT32                  CurrentByteOffset,
1038     UINT8                   *State);
1039
1040 /* Values for State above */
1041
1042 #define ACPI_RSTATE_NORMAL              0
1043 #define ACPI_RSTATE_START_DEPENDENT     1
1044 #define ACPI_RSTATE_DEPENDENT_LIST      2
1045
1046 UINT32
1047 RsLinkDescriptorChain (
1048     ASL_RESOURCE_NODE       **PreviousRnode,
1049     ASL_RESOURCE_NODE       *Rnode);
1050
1051 void
1052 RsDoResourceTemplate (
1053     ACPI_PARSE_OBJECT       *Op);
1054
1055
1056 /*
1057  * aslrestype1 - Miscellaneous Small descriptors
1058  */
1059 ASL_RESOURCE_NODE *
1060 RsDoEndTagDescriptor (
1061     ACPI_PARSE_OBJECT       *Op,
1062     UINT32                  CurrentByteOffset);
1063
1064 ASL_RESOURCE_NODE *
1065 RsDoEndDependentDescriptor (
1066     ACPI_PARSE_OBJECT       *Op,
1067     UINT32                  CurrentByteOffset);
1068
1069 ASL_RESOURCE_NODE *
1070 RsDoMemory24Descriptor (
1071     ACPI_PARSE_OBJECT       *Op,
1072     UINT32                  CurrentByteOffset);
1073
1074 ASL_RESOURCE_NODE *
1075 RsDoMemory32Descriptor (
1076     ACPI_PARSE_OBJECT       *Op,
1077     UINT32                  CurrentByteOffset);
1078
1079 ASL_RESOURCE_NODE *
1080 RsDoMemory32FixedDescriptor (
1081     ACPI_PARSE_OBJECT       *Op,
1082     UINT32                  CurrentByteOffset);
1083
1084 ASL_RESOURCE_NODE *
1085 RsDoStartDependentDescriptor (
1086     ACPI_PARSE_OBJECT       *Op,
1087     UINT32                  CurrentByteOffset);
1088
1089 ASL_RESOURCE_NODE *
1090 RsDoStartDependentNoPriDescriptor (
1091     ACPI_PARSE_OBJECT       *Op,
1092     UINT32                  CurrentByteOffset);
1093
1094 ASL_RESOURCE_NODE *
1095 RsDoVendorSmallDescriptor (
1096     ACPI_PARSE_OBJECT       *Op,
1097     UINT32                  CurrentByteOffset);
1098
1099
1100 /*
1101  * aslrestype1i - I/O-related Small descriptors
1102  */
1103 ASL_RESOURCE_NODE *
1104 RsDoDmaDescriptor (
1105     ACPI_PARSE_OBJECT       *Op,
1106     UINT32                  CurrentByteOffset);
1107
1108 ASL_RESOURCE_NODE *
1109 RsDoFixedDmaDescriptor (
1110     ACPI_PARSE_OBJECT       *Op,
1111     UINT32                  CurrentByteOffset);
1112
1113 ASL_RESOURCE_NODE *
1114 RsDoFixedIoDescriptor (
1115     ACPI_PARSE_OBJECT       *Op,
1116     UINT32                  CurrentByteOffset);
1117
1118 ASL_RESOURCE_NODE *
1119 RsDoIoDescriptor (
1120     ACPI_PARSE_OBJECT       *Op,
1121     UINT32                  CurrentByteOffset);
1122
1123 ASL_RESOURCE_NODE *
1124 RsDoIrqDescriptor (
1125     ACPI_PARSE_OBJECT       *Op,
1126     UINT32                  CurrentByteOffset);
1127
1128 ASL_RESOURCE_NODE *
1129 RsDoIrqNoFlagsDescriptor (
1130     ACPI_PARSE_OBJECT       *Op,
1131     UINT32                  CurrentByteOffset);
1132
1133
1134 /*
1135  * aslrestype2 - Large resource descriptors
1136  */
1137 ASL_RESOURCE_NODE *
1138 RsDoInterruptDescriptor (
1139     ACPI_PARSE_OBJECT       *Op,
1140     UINT32                  CurrentByteOffset);
1141
1142 ASL_RESOURCE_NODE *
1143 RsDoVendorLargeDescriptor (
1144     ACPI_PARSE_OBJECT       *Op,
1145     UINT32                  CurrentByteOffset);
1146
1147 ASL_RESOURCE_NODE *
1148 RsDoGeneralRegisterDescriptor (
1149     ACPI_PARSE_OBJECT       *Op,
1150     UINT32                  CurrentByteOffset);
1151
1152 ASL_RESOURCE_NODE *
1153 RsDoGpioIntDescriptor (
1154     ACPI_PARSE_OBJECT       *Op,
1155     UINT32                  CurrentByteOffset);
1156
1157 ASL_RESOURCE_NODE *
1158 RsDoGpioIoDescriptor (
1159     ACPI_PARSE_OBJECT       *Op,
1160     UINT32                  CurrentByteOffset);
1161
1162 ASL_RESOURCE_NODE *
1163 RsDoI2cSerialBusDescriptor (
1164     ACPI_PARSE_OBJECT       *Op,
1165     UINT32                  CurrentByteOffset);
1166
1167 ASL_RESOURCE_NODE *
1168 RsDoSpiSerialBusDescriptor (
1169     ACPI_PARSE_OBJECT       *Op,
1170     UINT32                  CurrentByteOffset);
1171
1172 ASL_RESOURCE_NODE *
1173 RsDoUartSerialBusDescriptor (
1174     ACPI_PARSE_OBJECT       *Op,
1175     UINT32                  CurrentByteOffset);
1176
1177 /*
1178  * aslrestype2d - DWord address descriptors
1179  */
1180 ASL_RESOURCE_NODE *
1181 RsDoDwordIoDescriptor (
1182     ACPI_PARSE_OBJECT       *Op,
1183     UINT32                  CurrentByteOffset);
1184
1185 ASL_RESOURCE_NODE *
1186 RsDoDwordMemoryDescriptor (
1187     ACPI_PARSE_OBJECT       *Op,
1188     UINT32                  CurrentByteOffset);
1189
1190 ASL_RESOURCE_NODE *
1191 RsDoDwordSpaceDescriptor (
1192     ACPI_PARSE_OBJECT       *Op,
1193     UINT32                  CurrentByteOffset);
1194
1195
1196 /*
1197  * aslrestype2e - Extended address descriptors
1198  */
1199 ASL_RESOURCE_NODE *
1200 RsDoExtendedIoDescriptor (
1201     ACPI_PARSE_OBJECT       *Op,
1202     UINT32                  CurrentByteOffset);
1203
1204 ASL_RESOURCE_NODE *
1205 RsDoExtendedMemoryDescriptor (
1206     ACPI_PARSE_OBJECT       *Op,
1207     UINT32                  CurrentByteOffset);
1208
1209 ASL_RESOURCE_NODE *
1210 RsDoExtendedSpaceDescriptor (
1211     ACPI_PARSE_OBJECT       *Op,
1212     UINT32                  CurrentByteOffset);
1213
1214
1215 /*
1216  * aslrestype2q - QWord address descriptors
1217  */
1218 ASL_RESOURCE_NODE *
1219 RsDoQwordIoDescriptor (
1220     ACPI_PARSE_OBJECT       *Op,
1221     UINT32                  CurrentByteOffset);
1222
1223 ASL_RESOURCE_NODE *
1224 RsDoQwordMemoryDescriptor (
1225     ACPI_PARSE_OBJECT       *Op,
1226     UINT32                  CurrentByteOffset);
1227
1228 ASL_RESOURCE_NODE *
1229 RsDoQwordSpaceDescriptor (
1230     ACPI_PARSE_OBJECT       *Op,
1231     UINT32                  CurrentByteOffset);
1232
1233
1234 /*
1235  * aslrestype2w - Word address descriptors
1236  */
1237 ASL_RESOURCE_NODE *
1238 RsDoWordIoDescriptor (
1239     ACPI_PARSE_OBJECT       *Op,
1240     UINT32                  CurrentByteOffset);
1241
1242 ASL_RESOURCE_NODE *
1243 RsDoWordSpaceDescriptor (
1244     ACPI_PARSE_OBJECT       *Op,
1245     UINT32                  CurrentByteOffset);
1246
1247 ASL_RESOURCE_NODE *
1248 RsDoWordBusNumberDescriptor (
1249     ACPI_PARSE_OBJECT       *Op,
1250     UINT32                  CurrentByteOffset);
1251
1252 /*
1253  * Entry to data table compiler subsystem
1254  */
1255 ACPI_STATUS
1256 DtDoCompile(
1257     void);
1258
1259 ACPI_STATUS
1260 DtCreateTemplates (
1261     char                    *Signature);
1262
1263 #endif /*  __ASLCOMPILER_H */