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 BOOLEAN
 279 ApFindNameInScope (
 280     char                    *Name,
 281     ACPI_PARSE_OBJECT       *Op);
 282
 283
 284 /*
 285  * aslerror - error handling/reporting
 286  */
 287 void
 288 AslAbort (
 289     void);
 290
 291 void
 292 AslError (
 293     UINT8                   Level,
 294     UINT16                  MessageId,
 295     ACPI_PARSE_OBJECT       *Op,
 296     char                    *ExtraMessage);
 297
 298 ACPI_STATUS
 299 AslDisableException (
 300     char                    *MessageIdString);
 301
 302 BOOLEAN
 303 AslIsExceptionDisabled (
 304     UINT8                   Level,
 305     UINT16                  MessageId);
 306
 307 void
 308 AslCoreSubsystemError (
 309     ACPI_PARSE_OBJECT       *Op,
 310     ACPI_STATUS             Status,
 311     char                    *ExtraMessage,
 312     BOOLEAN                 Abort);
 313
 314 int
 315 AslCompilererror(
 316     const char              *s);
 317
 318 void
 319 AslCommonError (
 320     UINT8                   Level,
 321     UINT16                  MessageId,
 322     UINT32                  CurrentLineNumber,
 323     UINT32                  LogicalLineNumber,
 324     UINT32                  LogicalByteOffset,
 325     UINT32                  Column,
 326     char                    *Filename,
 327     char                    *ExtraMessage);
 328
 329 void
 330 AslCommonError2 (
 331     UINT8                   Level,
 332     UINT16                  MessageId,
 333     UINT32                  LineNumber,
 334     UINT32                  Column,
 335     char                    *SourceLine,
 336     char                    *Filename,
 337     char                    *ExtraMessage);
 338
 339 void
 340 AePrintException (
 341     UINT32                  FileId,
 342     ASL_ERROR_MSG           *Enode,
 343     char                    *Header);
 344
 345 void
 346 AePrintErrorLog (
 347     UINT32                  FileId);
 348
 349 void
 350 AeClearErrorLog (
 351     void);
 352
 353 ACPI_PHYSICAL_ADDRESS
 354 AeLocalGetRootPointer (
 355     void);
 356
 357
 358 /*
 359  * asllisting - generate all "listing" type files
 360  */
 361 void
 362 LsDoListings (
 363     void);
 364
 365 void
 366 LsWriteNodeToAsmListing (
 367     ACPI_PARSE_OBJECT       *Op);
 368
 369 void
 370 LsWriteNode (
 371     ACPI_PARSE_OBJECT       *Op,
 372     UINT32                  FileId);
 373
 374 void
 375 LsDumpParseTree (
 376     void);
 377
 378
 379 /*
 380  * asllistsup - Listing file support utilities
 381  */
 382 void
 383 LsDumpAscii (
 384     UINT32                  FileId,
 385     UINT32                  Count,
 386     UINT8                   *Buffer);
 387
 388 void
 389 LsDumpAsciiInComment (
 390     UINT32                  FileId,
 391     UINT32                  Count,
 392     UINT8                   *Buffer);
 393
 394 void
 395 LsCheckException (
 396     UINT32                  LineNumber,
 397     UINT32                  FileId);
 398
 399 void
 400 LsFlushListingBuffer (
 401     UINT32                  FileId);
 402
 403 void
 404 LsWriteListingHexBytes (
 405     UINT8                   *Buffer,
 406     UINT32                  Length,
 407     UINT32                  FileId);
 408
 409 void
 410 LsWriteSourceLines (
 411     UINT32                  ToLineNumber,
 412     UINT32                  ToLogicalLineNumber,
 413     UINT32                  FileId);
 414
 415 UINT32
 416 LsWriteOneSourceLine (
 417     UINT32                  FileId);
 418
 419 void
 420 LsPushNode (
 421     char                    *Filename);
 422
 423 ASL_LISTING_NODE *
 424 LsPopNode (
 425     void);
 426
 427
 428 /*
 429  * aslhex - generate all "hex" output files (C, ASM, ASL)
 430  */
 431 void
 432 HxDoHexOutput (
 433     void);
 434
 435
 436 /*
 437  * aslfold - constant folding
 438  */
 439 ACPI_STATUS
 440 OpcAmlConstantWalk (
 441     ACPI_PARSE_OBJECT       *Op,
 442     UINT32                  Level,
 443     void                    *Context);
 444
 445
 446 /*
 447  * aslmessages - exception strings
 448  */
 449 const char *
 450 AeDecodeMessageId (
 451     UINT16                  MessageId);
 452
 453 const char *
 454 AeDecodeExceptionLevel (
 455     UINT8                   Level);
 456
 457 UINT16
 458 AeBuildFullExceptionCode (
 459     UINT8                   Level,
 460     UINT16                  MessageId);
 461
 462 /*
 463  * asloffset - generate C offset file for BIOS support
 464  */
 465 ACPI_STATUS
 466 LsAmlOffsetWalk (
 467     ACPI_PARSE_OBJECT       *Op,
 468     UINT32                  Level,
 469     void                    *Context);
 470
 471 void
 472 LsDoOffsetTableHeader (
 473     UINT32                  FileId);
 474
 475 void
 476 LsDoOffsetTableFooter (
 477     UINT32                  FileId);
 478
 479
 480 /*
 481  * aslopcodes - generate AML opcodes
 482  */
 483 ACPI_STATUS
 484 OpcAmlOpcodeWalk (
 485     ACPI_PARSE_OBJECT       *Op,
 486     UINT32                  Level,
 487     void                    *Context);
 488
 489 ACPI_STATUS
 490 OpcAmlOpcodeUpdateWalk (
 491     ACPI_PARSE_OBJECT       *Op,
 492     UINT32                  Level,
 493     void                    *Context);
 494
 495 void
 496 OpcGenerateAmlOpcode (
 497     ACPI_PARSE_OBJECT       *Op);
 498
 499 UINT32
 500 OpcSetOptimalIntegerSize (
 501     ACPI_PARSE_OBJECT       *Op);
 502
 503 void
 504 OpcGetIntegerWidth (
 505     ACPI_PARSE_OBJECT       *Op);
 506
 507
 508 /*
 509  * asloperands - generate AML operands for the AML opcodes
 510  */
 511 ACPI_PARSE_OBJECT  *
 512 UtGetArg (
 513     ACPI_PARSE_OBJECT       *Op,
 514     UINT32                  Argn);
 515
 516 void
 517 OpnGenerateAmlOperands (
 518     ACPI_PARSE_OBJECT       *Op);
 519
 520 void
 521 OpnDoPackage (
 522     ACPI_PARSE_OBJECT       *Op);
 523
 524
 525 /*
 526  * aslopt - optmization
 527  */
 528 void
 529 OptOptimizeNamePath (
 530     ACPI_PARSE_OBJECT       *Op,
 531     UINT32                  Flags,
 532     ACPI_WALK_STATE         *WalkState,
 533     char                    *AmlNameString,
 534     ACPI_NAMESPACE_NODE     *TargetNode);
 535
 536
 537 /*
 538  * aslcodegen - code generation
 539  */
 540 void
 541 CgGenerateAmlOutput (
 542     void);
 543
 544
 545 /*
 546  * aslfile
 547  */
 548 void
 549 FlOpenFile (
 550     UINT32                  FileId,
 551     char                    *Filename,
 552     char                    *Mode);
 553
 554
 555 /*
 556  * asllength - calculate/adjust AML package lengths
 557  */
 558 ACPI_STATUS
 559 LnPackageLengthWalk (
 560     ACPI_PARSE_OBJECT       *Op,
 561     UINT32                  Level,
 562     void                    *Context);
 563
 564 ACPI_STATUS
 565 LnInitLengthsWalk (
 566     ACPI_PARSE_OBJECT       *Op,
 567     UINT32                  Level,
 568     void                    *Context);
 569
 570 void
 571 CgGenerateAmlLengths (
 572     ACPI_PARSE_OBJECT       *Op);
 573
 574
 575 /*
 576  * aslmap - opcode mappings and reserved method names
 577  */
 578 ACPI_OBJECT_TYPE
 579 AslMapNamedOpcodeToDataType (
 580     UINT16                  Opcode);
 581
 582
 583 /*
 584  * aslpredef - ACPI predefined names support
 585  */
 586 BOOLEAN
 587 ApCheckForPredefinedMethod (
 588     ACPI_PARSE_OBJECT       *Op,
 589     ASL_METHOD_INFO         *MethodInfo);
 590
 591 void
 592 ApCheckPredefinedReturnValue (
 593     ACPI_PARSE_OBJECT       *Op,
 594     ASL_METHOD_INFO         *MethodInfo);
 595
 596 UINT32
 597 ApCheckForPredefinedName (
 598     ACPI_PARSE_OBJECT       *Op,
 599     char                    *Name);
 600
 601 void
 602 ApCheckForPredefinedObject (
 603     ACPI_PARSE_OBJECT       *Op,
 604     char                    *Name);
 605
 606 ACPI_STATUS
 607 ApCheckObjectType (
 608     const char              *PredefinedName,
 609     ACPI_PARSE_OBJECT       *Op,
 610     UINT32                  ExpectedBtypes,
 611     UINT32                  PackageIndex);
 612
 613 void
 614 ApDisplayReservedNames (
 615     void);
 616
 617
 618 /*
 619  * aslprepkg - ACPI predefined names support for packages
 620  */
 621 void
 622 ApCheckPackage (
 623     ACPI_PARSE_OBJECT           *ParentOp,
 624     const ACPI_PREDEFINED_INFO  *Predefined);
 625
 626
 627 /*
 628  * asltransform - parse tree transformations
 629  */
 630 ACPI_STATUS
 631 TrAmlTransformWalk (
 632     ACPI_PARSE_OBJECT       *Op,
 633     UINT32                  Level,
 634     void                    *Context);
 635
 636
 637 /*
 638  * asltree - parse tree support
 639  */
 640 ACPI_STATUS
 641 TrWalkParseTree (
 642     ACPI_PARSE_OBJECT       *Op,
 643     UINT32                  Visitation,
 644     ASL_WALK_CALLBACK       DescendingCallback,
 645     ASL_WALK_CALLBACK       AscendingCallback,
 646     void                    *Context);
 647
 648 /* Values for "Visitation" parameter above */
 649
 650 #define ASL_WALK_VISIT_DOWNWARD     0x01
 651 #define ASL_WALK_VISIT_UPWARD       0x02
 652 #define ASL_WALK_VISIT_TWICE        (ASL_WALK_VISIT_DOWNWARD | ASL_WALK_VISIT_UPWARD)
 653
 654
 655 ACPI_PARSE_OBJECT *
 656 TrAllocateNode (
 657     UINT32                  ParseOpcode);
 658
 659 void
 660 TrReleaseNode (
 661     ACPI_PARSE_OBJECT       *Op);
 662
 663 ACPI_PARSE_OBJECT *
 664 TrUpdateNode (
 665     UINT32                  ParseOpcode,
 666     ACPI_PARSE_OBJECT       *Op);
 667
 668 ACPI_PARSE_OBJECT *
 669 TrCreateNode (
 670     UINT32                  ParseOpcode,
 671     UINT32                  NumChildren,
 672     ...);
 673
 674 ACPI_PARSE_OBJECT *
 675 TrCreateLeafNode (
 676     UINT32                  ParseOpcode);
 677
 678 ACPI_PARSE_OBJECT *
 679 TrCreateValuedLeafNode (
 680     UINT32                  ParseOpcode,
 681     UINT64                  Value);
 682
 683 ACPI_PARSE_OBJECT *
 684 TrCreateConstantLeafNode (
 685     UINT32                  ParseOpcode);
 686
 687 ACPI_PARSE_OBJECT *
 688 TrLinkChildren (
 689     ACPI_PARSE_OBJECT       *Op,
 690     UINT32                  NumChildren,
 691     ...);
 692
 693 void
 694 TrSetEndLineNumber (
 695     ACPI_PARSE_OBJECT       *Op);
 696
 697 void
 698 TrWalkTree (
 699     void);
 700
 701 ACPI_PARSE_OBJECT *
 702 TrLinkPeerNode (
 703     ACPI_PARSE_OBJECT       *Op1,
 704     ACPI_PARSE_OBJECT       *Op2);
 705
 706 ACPI_PARSE_OBJECT *
 707 TrLinkChildNode (
 708     ACPI_PARSE_OBJECT       *Op1,
 709     ACPI_PARSE_OBJECT       *Op2);
 710
 711 ACPI_PARSE_OBJECT *
 712 TrSetNodeFlags (
 713     ACPI_PARSE_OBJECT       *Op,
 714     UINT32                  Flags);
 715
 716 ACPI_PARSE_OBJECT *
 717 TrSetNodeAmlLength (
 718     ACPI_PARSE_OBJECT       *Op,
 719     UINT32                  Length);
 720
 721 ACPI_PARSE_OBJECT *
 722 TrLinkPeerNodes (
 723     UINT32                  NumPeers,
 724     ...);
 725
 726
 727 /*
 728  * aslfiles - File I/O support
 729  */
 730 void
 731 FlAddIncludeDirectory (
 732     char                    *Dir);
 733
 734 char *
 735 FlMergePathnames (
 736     char                    *PrefixDir,
 737     char                    *FilePathname);
 738
 739 void
 740 FlOpenIncludeFile (
 741     ACPI_PARSE_OBJECT       *Op);
 742
 743 void
 744 FlFileError (
 745     UINT32                  FileId,
 746     UINT8                   ErrorId);
 747
 748 UINT32
 749 FlGetFileSize (
 750     UINT32                  FileId);
 751
 752 ACPI_STATUS
 753 FlReadFile (
 754     UINT32                  FileId,
 755     void                    *Buffer,
 756     UINT32                  Length);
 757
 758 void
 759 FlWriteFile (
 760     UINT32                  FileId,
 761     void                    *Buffer,
 762     UINT32                  Length);
 763
 764 void
 765 FlSeekFile (
 766     UINT32                  FileId,
 767     long                    Offset);
 768
 769 void
 770 FlCloseFile (
 771     UINT32                  FileId);
 772
 773 void
 774 FlPrintFile (
 775     UINT32                  FileId,
 776     char                    *Format,
 777     ...);
 778
 779 void
 780 FlDeleteFile (
 781     UINT32                  FileId);
 782
 783 void
 784 FlSetLineNumber (
 785     UINT32                  LineNumber);
 786
 787 void
 788 FlSetFilename (
 789     char                    *Filename);
 790
 791 ACPI_STATUS
 792 FlOpenInputFile (
 793     char                    *InputFilename);
 794
 795 ACPI_STATUS
 796 FlOpenAmlOutputFile (
 797     char                    *InputFilename);
 798
 799 ACPI_STATUS
 800 FlOpenMiscOutputFiles (
 801     char                    *InputFilename);
 802
 803
 804 /*
 805  * asload - load namespace in prep for cross reference
 806  */
 807 ACPI_STATUS
 808 LdLoadNamespace (
 809     ACPI_PARSE_OBJECT       *RootOp);
 810
 811
 812 /*
 813  * asllookup - namespace lookup functions
 814  */
 815 void
 816 LkFindUnreferencedObjects (
 817     void);
 818
 819 /*
 820  * aslmain - startup
 821  */
 822 void
 823 Usage (
 824     void);
 825
 826 void
 827 AslFilenameHelp (
 828     void);
 829
 830
 831 /*
 832  * aslnamesp - namespace output file generation
 833  */
 834 ACPI_STATUS
 835 NsDisplayNamespace (
 836     void);
 837
 838 void
 839 NsSetupNamespaceListing (
 840     void                    *Handle);
 841
 842 /*
 843  * asloptions - command line processing
 844  */
 845 int
 846 AslCommandLine (
 847     int                     argc,
 848     char                    **argv);
 849
 850 /*
 851  * aslxref - namespace cross reference
 852  */
 853 ACPI_STATUS
 854 XfCrossReferenceNamespace (
 855     void);
 856
 857
 858 /*
 859  * aslutils - common compiler utilites
 860  */
 861 void
 862 DbgPrint (
 863     UINT32                  Type,
 864     char                    *Format,
 865     ...);
 866
 867 /* Type values for above */
 868
 869 #define ASL_DEBUG_OUTPUT    0
 870 #define ASL_PARSE_OUTPUT    1
 871 #define ASL_TREE_OUTPUT     2
 872
 873 void
 874 UtDisplaySupportedTables (
 875     void);
 876
 877 void
 878 UtDisplayConstantOpcodes (
 879     void);
 880
 881 UINT8
 882 UtBeginEvent (
 883     char                    *Name);
 884
 885 void
 886 UtEndEvent (
 887     UINT8                   Event);
 888
 889 void *
 890 UtLocalCalloc (
 891     UINT32                  Size);
 892
 893 void
 894 UtPrintFormattedName (
 895     UINT16                  ParseOpcode,
 896     UINT32                  Level);
 897
 898 void
 899 UtDisplaySummary (
 900     UINT32                  FileId);
 901
 902 UINT8
 903 UtHexCharToValue (
 904     int                     HexChar);
 905
 906 void
 907 UtConvertByteToHex (
 908     UINT8                   RawByte,
 909     UINT8                   *Buffer);
 910
 911 void
 912 UtConvertByteToAsmHex (
 913     UINT8                   RawByte,
 914     UINT8                   *Buffer);
 915
 916 char *
 917 UtGetOpName (
 918     UINT32                  ParseOpcode);
 919
 920 void
 921 UtSetParseOpName (
 922     ACPI_PARSE_OBJECT       *Op);
 923
 924 char *
 925 UtGetStringBuffer (
 926     UINT32                  Length);
 927
 928 void
 929 UtExpandLineBuffers (
 930     void);
 931
 932 ACPI_STATUS
 933 UtInternalizeName (
 934     char                    *ExternalName,
 935     char                    **ConvertedName);
 936
 937 void
 938 UtAttachNamepathToOwner (
 939     ACPI_PARSE_OBJECT       *Op,
 940     ACPI_PARSE_OBJECT       *NameNode);
 941
 942 ACPI_PARSE_OBJECT *
 943 UtCheckIntegerRange (
 944     ACPI_PARSE_OBJECT       *Op,
 945     UINT32                  LowValue,
 946     UINT32                  HighValue);
 947
 948 UINT64
 949 UtDoConstant (
 950     char                    *String);
 951
 952 ACPI_STATUS
 953 UtStrtoul64 (
 954     char                    *String,
 955     UINT32                  Base,
 956     UINT64                  *RetInteger);
 957
 958
 959 /*
 960  * asluuid - UUID support
 961  */
 962 ACPI_STATUS
 963 AuValidateUuid (
 964     char                    *InString);
 965
 966 ACPI_STATUS
 967 AuConvertStringToUuid (
 968     char                    *InString,
 969     char                    *UuIdBuffer);
 970
 971 ACPI_STATUS
 972 AuConvertUuidToString (
 973     char                    *UuIdBuffer,
 974     char                    *OutString);
 975
 976 /*
 977  * aslresource - Resource template generation utilities
 978  */
 979 void
 980 RsSmallAddressCheck (
 981     UINT8                   Type,
 982     UINT32                  Minimum,
 983     UINT32                  Maximum,
 984     UINT32                  Length,
 985     UINT32                  Alignment,
 986     ACPI_PARSE_OBJECT       *MinOp,
 987     ACPI_PARSE_OBJECT       *MaxOp,
 988     ACPI_PARSE_OBJECT       *LengthOp,
 989     ACPI_PARSE_OBJECT       *AlignOp,
 990     ACPI_PARSE_OBJECT       *Op);
 991
 992 void
 993 RsLargeAddressCheck (
 994     UINT64                  Minimum,
 995     UINT64                  Maximum,
 996     UINT64                  Length,
 997     UINT64                  Granularity,
 998     UINT8                   Flags,
 999     ACPI_PARSE_OBJECT       *MinOp,
1000     ACPI_PARSE_OBJECT       *MaxOp,
1001     ACPI_PARSE_OBJECT       *LengthOp,
1002     ACPI_PARSE_OBJECT       *GranOp,
1003     ACPI_PARSE_OBJECT       *Op);
1004
1005 UINT16
1006 RsGetStringDataLength (
1007     ACPI_PARSE_OBJECT       *InitializerOp);
1008
1009 ASL_RESOURCE_NODE *
1010 RsAllocateResourceNode (
1011     UINT32                  Size);
1012
1013 void
1014 RsCreateResourceField (
1015     ACPI_PARSE_OBJECT       *Op,
1016     char                    *Name,
1017     UINT32                  ByteOffset,
1018     UINT32                  BitOffset,
1019     UINT32                  BitLength);
1020
1021 void
1022 RsSetFlagBits (
1023     UINT8                   *Flags,
1024     ACPI_PARSE_OBJECT       *Op,
1025     UINT8                   Position,
1026     UINT8                   DefaultBit);
1027
1028 void
1029 RsSetFlagBits16 (
1030     UINT16                  *Flags,
1031     ACPI_PARSE_OBJECT       *Op,
1032     UINT8                   Position,
1033     UINT8                   DefaultBit);
1034
1035 ACPI_PARSE_OBJECT *
1036 RsCompleteNodeAndGetNext (
1037     ACPI_PARSE_OBJECT       *Op);
1038
1039 void
1040 RsCheckListForDuplicates (
1041     ACPI_PARSE_OBJECT       *Op);
1042
1043 ASL_RESOURCE_NODE *
1044 RsDoOneResourceDescriptor (
1045     ACPI_PARSE_OBJECT       *DescriptorTypeOp,
1046     UINT32                  CurrentByteOffset,
1047     UINT8                   *State);
1048
1049 /* Values for State above */
1050
1051 #define ACPI_RSTATE_NORMAL              0
1052 #define ACPI_RSTATE_START_DEPENDENT     1
1053 #define ACPI_RSTATE_DEPENDENT_LIST      2
1054
1055 UINT32
1056 RsLinkDescriptorChain (
1057     ASL_RESOURCE_NODE       **PreviousRnode,
1058     ASL_RESOURCE_NODE       *Rnode);
1059
1060 void
1061 RsDoResourceTemplate (
1062     ACPI_PARSE_OBJECT       *Op);
1063
1064
1065 /*
1066  * aslrestype1 - Miscellaneous Small descriptors
1067  */
1068 ASL_RESOURCE_NODE *
1069 RsDoEndTagDescriptor (
1070     ACPI_PARSE_OBJECT       *Op,
1071     UINT32                  CurrentByteOffset);
1072
1073 ASL_RESOURCE_NODE *
1074 RsDoEndDependentDescriptor (
1075     ACPI_PARSE_OBJECT       *Op,
1076     UINT32                  CurrentByteOffset);
1077
1078 ASL_RESOURCE_NODE *
1079 RsDoMemory24Descriptor (
1080     ACPI_PARSE_OBJECT       *Op,
1081     UINT32                  CurrentByteOffset);
1082
1083 ASL_RESOURCE_NODE *
1084 RsDoMemory32Descriptor (
1085     ACPI_PARSE_OBJECT       *Op,
1086     UINT32                  CurrentByteOffset);
1087
1088 ASL_RESOURCE_NODE *
1089 RsDoMemory32FixedDescriptor (
1090     ACPI_PARSE_OBJECT       *Op,
1091     UINT32                  CurrentByteOffset);
1092
1093 ASL_RESOURCE_NODE *
1094 RsDoStartDependentDescriptor (
1095     ACPI_PARSE_OBJECT       *Op,
1096     UINT32                  CurrentByteOffset);
1097
1098 ASL_RESOURCE_NODE *
1099 RsDoStartDependentNoPriDescriptor (
1100     ACPI_PARSE_OBJECT       *Op,
1101     UINT32                  CurrentByteOffset);
1102
1103 ASL_RESOURCE_NODE *
1104 RsDoVendorSmallDescriptor (
1105     ACPI_PARSE_OBJECT       *Op,
1106     UINT32                  CurrentByteOffset);
1107
1108
1109 /*
1110  * aslrestype1i - I/O-related Small descriptors
1111  */
1112 ASL_RESOURCE_NODE *
1113 RsDoDmaDescriptor (
1114     ACPI_PARSE_OBJECT       *Op,
1115     UINT32                  CurrentByteOffset);
1116
1117 ASL_RESOURCE_NODE *
1118 RsDoFixedDmaDescriptor (
1119     ACPI_PARSE_OBJECT       *Op,
1120     UINT32                  CurrentByteOffset);
1121
1122 ASL_RESOURCE_NODE *
1123 RsDoFixedIoDescriptor (
1124     ACPI_PARSE_OBJECT       *Op,
1125     UINT32                  CurrentByteOffset);
1126
1127 ASL_RESOURCE_NODE *
1128 RsDoIoDescriptor (
1129     ACPI_PARSE_OBJECT       *Op,
1130     UINT32                  CurrentByteOffset);
1131
1132 ASL_RESOURCE_NODE *
1133 RsDoIrqDescriptor (
1134     ACPI_PARSE_OBJECT       *Op,
1135     UINT32                  CurrentByteOffset);
1136
1137 ASL_RESOURCE_NODE *
1138 RsDoIrqNoFlagsDescriptor (
1139     ACPI_PARSE_OBJECT       *Op,
1140     UINT32                  CurrentByteOffset);
1141
1142
1143 /*
1144  * aslrestype2 - Large resource descriptors
1145  */
1146 ASL_RESOURCE_NODE *
1147 RsDoInterruptDescriptor (
1148     ACPI_PARSE_OBJECT       *Op,
1149     UINT32                  CurrentByteOffset);
1150
1151 ASL_RESOURCE_NODE *
1152 RsDoVendorLargeDescriptor (
1153     ACPI_PARSE_OBJECT       *Op,
1154     UINT32                  CurrentByteOffset);
1155
1156 ASL_RESOURCE_NODE *
1157 RsDoGeneralRegisterDescriptor (
1158     ACPI_PARSE_OBJECT       *Op,
1159     UINT32                  CurrentByteOffset);
1160
1161 ASL_RESOURCE_NODE *
1162 RsDoGpioIntDescriptor (
1163     ACPI_PARSE_OBJECT       *Op,
1164     UINT32                  CurrentByteOffset);
1165
1166 ASL_RESOURCE_NODE *
1167 RsDoGpioIoDescriptor (
1168     ACPI_PARSE_OBJECT       *Op,
1169     UINT32                  CurrentByteOffset);
1170
1171 ASL_RESOURCE_NODE *
1172 RsDoI2cSerialBusDescriptor (
1173     ACPI_PARSE_OBJECT       *Op,
1174     UINT32                  CurrentByteOffset);
1175
1176 ASL_RESOURCE_NODE *
1177 RsDoSpiSerialBusDescriptor (
1178     ACPI_PARSE_OBJECT       *Op,
1179     UINT32                  CurrentByteOffset);
1180
1181 ASL_RESOURCE_NODE *
1182 RsDoUartSerialBusDescriptor (
1183     ACPI_PARSE_OBJECT       *Op,
1184     UINT32                  CurrentByteOffset);
1185
1186 /*
1187  * aslrestype2d - DWord address descriptors
1188  */
1189 ASL_RESOURCE_NODE *
1190 RsDoDwordIoDescriptor (
1191     ACPI_PARSE_OBJECT       *Op,
1192     UINT32                  CurrentByteOffset);
1193
1194 ASL_RESOURCE_NODE *
1195 RsDoDwordMemoryDescriptor (
1196     ACPI_PARSE_OBJECT       *Op,
1197     UINT32                  CurrentByteOffset);
1198
1199 ASL_RESOURCE_NODE *
1200 RsDoDwordSpaceDescriptor (
1201     ACPI_PARSE_OBJECT       *Op,
1202     UINT32                  CurrentByteOffset);
1203
1204
1205 /*
1206  * aslrestype2e - Extended address descriptors
1207  */
1208 ASL_RESOURCE_NODE *
1209 RsDoExtendedIoDescriptor (
1210     ACPI_PARSE_OBJECT       *Op,
1211     UINT32                  CurrentByteOffset);
1212
1213 ASL_RESOURCE_NODE *
1214 RsDoExtendedMemoryDescriptor (
1215     ACPI_PARSE_OBJECT       *Op,
1216     UINT32                  CurrentByteOffset);
1217
1218 ASL_RESOURCE_NODE *
1219 RsDoExtendedSpaceDescriptor (
1220     ACPI_PARSE_OBJECT       *Op,
1221     UINT32                  CurrentByteOffset);
1222
1223
1224 /*
1225  * aslrestype2q - QWord address descriptors
1226  */
1227 ASL_RESOURCE_NODE *
1228 RsDoQwordIoDescriptor (
1229     ACPI_PARSE_OBJECT       *Op,
1230     UINT32                  CurrentByteOffset);
1231
1232 ASL_RESOURCE_NODE *
1233 RsDoQwordMemoryDescriptor (
1234     ACPI_PARSE_OBJECT       *Op,
1235     UINT32                  CurrentByteOffset);
1236
1237 ASL_RESOURCE_NODE *
1238 RsDoQwordSpaceDescriptor (
1239     ACPI_PARSE_OBJECT       *Op,
1240     UINT32                  CurrentByteOffset);
1241
1242
1243 /*
1244  * aslrestype2w - Word address descriptors
1245  */
1246 ASL_RESOURCE_NODE *
1247 RsDoWordIoDescriptor (
1248     ACPI_PARSE_OBJECT       *Op,
1249     UINT32                  CurrentByteOffset);
1250
1251 ASL_RESOURCE_NODE *
1252 RsDoWordSpaceDescriptor (
1253     ACPI_PARSE_OBJECT       *Op,
1254     UINT32                  CurrentByteOffset);
1255
1256 ASL_RESOURCE_NODE *
1257 RsDoWordBusNumberDescriptor (
1258     ACPI_PARSE_OBJECT       *Op,
1259     UINT32                  CurrentByteOffset);
1260
1261 /*
1262  * Entry to data table compiler subsystem
1263  */
1264 ACPI_STATUS
1265 DtDoCompile(
1266     void);
1267
1268 ACPI_STATUS
1269 DtCreateTemplates (
1270     char                    *Signature);
1271
1272 #endif /*  __ASLCOMPILER_H */