sys/contrib/dev/acpica/source/tools/acpihelp/ahaslops.c

   1 /******************************************************************************
   2  *
   3  * Module Name: ahaslops - Table of all known ASL operators
   4  *
   5  *****************************************************************************/
   6
   7 /******************************************************************************
   8  *
   9  * 1. Copyright Notice
  10  *
  11  * Some or all of this work - Copyright (c) 1999 - 2019, 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 #include "acpihelp.h"
 153
 154 /*
 155  * ASL operators with syntax (directly from ACPI specification).
 156  * Note: All tokens require a space separator.
 157  * Long lines are automatically split during output.
 158  */
 159 const AH_ASL_OPERATOR       Gbl_AslOperatorInfo[] =
 160 {
 161     {"AccessAs",                "(AccessType, AccessAttribKeyword | "
 162                                 "ExtendedAttribKeyword (AccessLength))",
 163                                 "ChangeFieldUnitAccess"},
 164     {"Acquire",                 "(SyncObject, TimeoutValue) => Boolean",
 165                                 "Acquire a mutex"},
 166     {"Add",                     "(Addend1, Addend2, Result) => Integer",
 167                                 "Integer Add"},
 168     {"Alias",                   "(SourceObject, AliasObject)",
 169                                 "Define a name alias"},
 170     {"And",                     "(Source1, Source2, Result) => Integer",
 171                                 "Integer Bitwise And"},
 172     {"Arg",                     "Arg0 - Arg6",
 173                                 "Method argument data objects"},
 174     {"BankField",               "(RegionName, BankName, BankValue, "
 175                                 "AccessTypeKeyword, LockRuleKeyword, "
 176                                 "UpdateRuleKeyword) {FieldUnitList}",
 177                                 "Declare fields in a banked configuration object"},
 178     {"Break",                   "No parameters",
 179                                 "Continue following the innermost enclosing While"},
 180     {"BreakPoint",              "No parameters",
 181                                 "Used for debugging, stops execution in the debugger"},
 182     {"Buffer",                  "(BufferSize) {String or ByteList} => Buffer",
 183                                 "Declare Buffer object"},
 184     {"Case",                    "(Value) {TermList}",
 185                                 "Expression for conditional execution"},
 186     {"Concatenate",             "(Source1, Source2, Result) => ComputationalData",
 187                                 "Concatenate two strings, integers or buffers"},
 188     {"ConcatenateResTemplate",  "(Source1, Source2, Result) => Buffer",
 189                                 "Concatenate two resource templates"},
 190     {"CondRefOf",               "(Source, Result) => Boolean",
 191                                 "Conditional reference to an object"},
 192     {"Connection",              "(ResourceMacro)",
 193                                 "Associate connection with FieldUnits within a Field object"},
 194     {"Continue",                "No parameters",
 195                                 "Continue innermost enclosing While loop"},
 196     {"CopyObject",              "(Source, Destination) => DataRefObject",
 197                                 "Copy and existing object"},
 198     {"CreateBitField",          "(SourceBuffer, BitIndex, BitFieldName)",
 199                                 "Declare a bit field object of a buffer object"},
 200     {"CreateByteField",         "(SourceBuffer, ByteIndex, ByteFieldName)",
 201                                 "Declare a byte field object of a buffer object"},
 202     {"CreateDWordField",        "(SourceBuffer, ByteIndex, DWordFieldName)",
 203                                 "Declare a DWord field object of a buffer object"},
 204     {"CreateField",             "(SourceBuffer, BitIndex, NumBits, FieldName)",
 205                                 "Declare an arbitrary length bit field of a buffer object"},
 206     {"CreateQWordField",        "(SourceBuffer, ByteIndex, QWordFieldName)",
 207                                 "Declare a QWord field object of a buffer object"},
 208     {"CreateWordField",         "(SourceBuffer, ByteIndex, WordFieldName)",
 209                                 "Declare a Word field object of a buffer object"},
 210     {"DataTableRegion",         "(RegionName, SignatureString, OemIDString, OemTableIDString)",
 211                                 "Declare a Data Table Region"},
 212     {"Debug",                   "No parameters",
 213                                 "Debugger output"},
 214     {"Decrement",               "(Minuend) => Integer",
 215                                 "Decrement an Integer"},
 216     {"Default",                 "{TermList}",
 217                                 "Default execution path in Switch()"},
 218     {"DefinitionBlock",         "(AmlFileName, TableSignature, ComplianceRevision, "
 219                                 "OemId, TableId, OemRevision) {TermList}",
 220                                 "Declare a Definition Block"},
 221     {"DerefOf",                 "(Source) => Object",
 222                                 "Dereference an object reference"},
 223     {"Device",                  "(DeviceName) {TermList}",
 224                                 "Declare a bus/device object"},
 225     {"Divide",                  "(Dividend, Divisor, Remainder, Result) => Integer",
 226                                 "Integer Divide"},
 227     {"Dma",                     "(DmaTypeKeyword, BusMasterKeyword, XferTypeKeyword, "
 228                                 "DescriptorName) {DmaChannelList} => Buffer",
 229                                 "DMA Resource Descriptor macro"},
 230     {"DWordIo",                 "(ResourceTypeKeyword, MinKeyword, MaxKeyword, "
 231                                 "DecodeKeyword, RangeTypeKeyword, AddressGranularity, "
 232                                 "AddressMinimum, AddressMaximum, AddressTranslation, "
 233                                 "RangeLength, ResourceSourceIndex, "
 234                                 "ResourceSource, DescriptorName, TypeKeyword, TranslationKeyword)",
 235                                 "DWord I/O Resource Descriptor macro"},
 236     {"DWordMemory",             "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
 237                                 "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, "
 238                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 239                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName, AddressKeyword, "
 240                                 "TypeKeyword)",
 241                                 "DWord Memory Resource Descriptor macro"},
 242     {"DWordSpace",              "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
 243                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
 244                                 "AddressGranularity, AddressMinimum, AddressMaximum, "
 245                                 "AddressTranslation, RangeLength, "
 246                                 "ResourceSourceIndex, ResourceSource, DescriptorName)",
 247                                 "DWord Space Resource Descriptor macro"},
 248     {"EisaId",                  "(EisaIdString) => DWordConst",
 249                                 "EISA ID String to Integer conversion macro"},
 250     {"Else",                    "{TermList}",
 251                                 "Alternate conditional execution"},
 252     {"ElseIf",                  "(Predicate)",
 253                                 "Conditional execution"},
 254     {"EndDependentFn",          "() => Buffer",
 255                                 "End Dependent Function Resource Descriptor macro"},
 256     {"Event",                   "(EventName)",
 257                                 "Declare an event synchronization object"},
 258     {"ExtendedIo",              "(ResourceTypeKeyword, MinKeyword, MaxKeyword, "
 259                                 "DecodeKeyword, RangeTypeKeyword, AddressGranularity, "
 260                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
 261                                 "TypeSpecificAttributes, DescriptorName, TypeKeyword, TranslationKeyword)",
 262                                 "Extended I/O Resource Descriptor macro"},
 263     {"ExtendedMemory",          "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
 264                                 "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, "
 265                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 266                                 "RangeLength, TypeSpecificAttributes, DescriptorName, "
 267                                 "AddressKeyword, TypeKeyword)",
 268                                 "Extended Memory Resource Descriptor macro"},
 269     {"ExtendedSpace",           "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
 270                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
 271                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 272                                 "RangeLength, TypeSpecificAttributes, DescriptorName)",
 273                                 "Extended Space Resource Descriptor macro"},
 274     {"External",                "(ObjectName, ObjectTypeKeyword, ReturnType, ParameterTypes)",
 275                                 "Declare external objects"},
 276     {"Fatal",                   "(Type, Code, Arg)",
 277                                 "Fatal error check"},
 278     {"Field",                   "(RegionName, AccessTypeKeyword, LockRuleKeyword, "
 279                                 "UpdateRuleKeyword) {FieldUnitList}",
 280                                 "Declare fields of an operation region object"},
 281     {"FindSetLeftBit",          "(Source, Result) => Integer",
 282                                 "Index of first least significant bit set"},
 283     {"FindSetRightBit",         "(Source, Result) => Integer",
 284                                 "Index of first most significant bit set"},
 285     {"FixedDma",                "(DmaRequestLine, Channel, TransferWidthKeyword, DescriptorName) => Buffer",
 286                                 "Fixed DMA Resource Descriptor macro"},
 287     {"FixedIo",                 "(AddressBase, RangeLength, DescriptorName) => Buffer",
 288                                 "Fixed I/O Resource Descriptor macro"},
 289     {"FromBcd",                 "(BcdValue, Result) => Integer",
 290                                 "Convert from BCD to numeric"},
 291     {"Function",                "(FunctionName, ReturnType, ParameterTypes) {TermList}",
 292                                 "Declare control method"},
 293     {"GpioInt",                 "(InterruptTypeKeyword, InterruptLevelKeyword, "
 294                                 "ShareTypeKeyword, PinConfigKeyword, "
 295                                 "DebounceTimeout, ResourceSource, "
 296                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
 297                                 "RawDataBuffer() {VendorData}) {Pin}",
 298                                 "GPIO Interrupt Connection Resource Descriptor Macro"},
 299     {"GpioIo",                  "(ShareTypeKeyword, PinConfigKeyword, DebounceTimeout, DriveStrength, "
 300                                 "IoRestrictionKeyword, ResourceSource, "
 301                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
 302                                 "RawDataBuffer() {VendorData}) {PinList}",
 303                                 "GPIO I/O Connection Resource Descriptor Macro"},
 304     {"I2cSerialBusV2",           "(SlaveAddress, SlaveModeKeyword, ConnectionSpeed, "
 305                                 "AddressingModeKeyword, ResourceSource, "
 306                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, Shared, "
 307                                 "RawDataBuffer() {VendorData})",
 308                                 "I2C Serial Bus Connection Resource Descriptor Macro"},
 309     {"If",                      "(Predicate) {TermList}",
 310                                 "Conditional execution"},
 311     {"Include",                 "(FilePathName)",
 312                                 "Include another ASL file"},
 313     {"Increment",               "(Addend) => Integer",
 314                                 "Increment a Integer"},
 315     {"Index",                   "(Source, Index, Destination) => ObjectReference",
 316                                 "Indexed Reference to member object"},
 317     {"IndexField",              "(IndexName, DataName, AccessTypeKeyword, LockRuleKeyword, "
 318                                 "UpdateRuleKeyword) {FieldUnitList}",
 319                                 "Declare Index/Data Fields"},
 320     {"Interrupt",               "(ResourceTypeKeyword, InterruptTypeKeyword, InterruptLevelKeyword, "
 321                                 "ShareTypeKeyword, ResourceSourceIndex, "
 322                                 "ResourceSource, DescriptorName) {InterruptList} => Buffer",
 323                                 "Interrupt Resource Descriptor macro"},
 324     {"Io",                      "(IoDecodeKeyword, AddressMin, AddressMax, AddressAlignment, "
 325                                 "RangeLength, DescriptorName) => Buffer",
 326                                 "I/O Resource Descriptor macro"},
 327     {"Irq",                     "(InterruptTypeKeyword, InterruptLevelKeyword, ShareTypeKeyword, "
 328                                 "DescriptorName) {InterruptList} => Buffer",
 329                                 "Interrupt Resource Descriptor macro"},
 330     {"IrqNoFlags",              "(DescriptorName) {InterruptList} => Buffer",
 331                                 "Short Interrupt Resource Descriptor macro"},
 332     {"LAnd",                    "(Source1, Source2) => Boolean",
 333                                 "Logical And"},
 334     {"LEqual",                  "(Source1, Source2) => Boolean",
 335                                 "Logical Equal"},
 336     {"LGreater",                "(Source1, Source2) => Boolean",
 337                                 "Logical Greater"},
 338     {"LGreaterEqual",           "(Source1, Source2) => Boolean",
 339                                 "Logical Not less"},
 340     {"LLess",                   "(Source1, Source2) => Boolean",
 341                                 "Logical Less"},
 342     {"LLessEqual",              "(Source1, Source2) => Boolean",
 343                                 "Logical Not greater"},
 344     {"LNot",                    "(Source) => Boolean",
 345                                 "Logical Not"},
 346     {"LNotEqual",               "(Source1, Source2) => Boolean",
 347                                 "Logical Not equal"},
 348     {"Load",                    "(Object, DDBHandle)",
 349                                 "Load differentiating definition block"},
 350     {"LoadTable",               "(SignatureString, OemIdString, OemTableIdString, RootPathString, "
 351                                 "ParameterPathString, ParameterData) => DDBHandle",
 352                                 "Load Table from RSDT/XSDT"},
 353     {"Local",                   "Local0 - Local7",
 354                                 "Method local data objects"},
 355     {"LOr",                     "(Source1, Source2) => Boolean",
 356                                 "Logical Or"},
 357     {"Match",                   "(SearchPackage, MatchOpKeyword, MatchObject1, MatchOpKeyword, "
 358                                 "MatchObject2, StartIndex) => Ones | Integer",
 359                                 "Search for match in package array"},
 360     {"Memory24",                "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, "
 361                                 "RangeLength, DescriptorName)",
 362                                 "Memory Resource Descriptor macro"},
 363     {"Memory32",                "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, "
 364                                 "RangeLength, DescriptorName)",
 365                                 "Memory Resource Descriptor macro"},
 366     {"Memory32Fixed",           "(ReadWriteKeyword, AddressBase, RangeLength, DescriptorName)",
 367                                 "Memory Resource Descriptor macro"},
 368     {"Method",                  "(MethodName, NumArgs, SerializeRuleKeyword, "
 369                                 "SyncLevel, ReturnType, ParameterTypes) "
 370                                 "{TermList}",
 371                                 "Declare a control method"},
 372     {"Mid",                     "(Source, Index, Length, Result) => Buffer or String",
 373                                 "Return a portion of buffer or string"},
 374     {"Mod",                     "(Dividend, Divisor, Result) => Integer",
 375                                 "Integer Modulo"},
 376     {"Multiply",                "(Multiplicand, Multiplier, Result) => Integer",
 377                                 "Integer Multiply"},
 378     {"Mutex",                   "(MutexName, SyncLevel)",
 379                                 "Declare a mutex synchronization object"},
 380     {"Name",                    "(ObjectName, Object)",
 381                                 "Declare a Named object"},
 382     {"NAnd",                    "(Source1, Source2, Result) => Integer",
 383                                 "Integer Bitwise Nand"},
 384     {"NoOp",                    "No parameters",
 385                                 "No operation"},
 386     {"NOr",                     "(Source1, Source2, Result) => Integer",
 387                                 "Integer Bitwise Nor"},
 388     {"Not",                     "(Source, Result) => Integer",
 389                                 "Integer Bitwise Not"},
 390     {"Notify",                  "(Object, NotificationValue)",
 391                                 "Notify Object of event"},
 392     {"ObjectType",              "(Object) => Integer",
 393                                 "Type of object"},
 394     {"Offset",                  "(ByteOffset)",
 395                                 "Change Current Field Unit Offset"},
 396     {"One",                     "=> Integer",
 397                                 "Constant One Object (1)"},
 398     {"Ones",                    "=> Integer",
 399                                 "Constant Ones Object (0xFFFFFFFF or 0xFFFFFFFFFFFFFFFF)"},
 400     {"OperationRegion",         "(RegionName, RegionSpaceKeyword, Offset, Length)",
 401                                 "Declare an operational region"},
 402     {"Or",                      "(Source1, Source2, Result) => Integer",
 403                                 "Integer Bitwise Or"},
 404     {"Package",                 "(NumElements) {PackageList} => Package",
 405                                 "Declare a package object"},
 406     {"PowerResource",           "(ResourceName, SystemLevel, ResourceOrder) {TermList}",
 407                                 "Declare a power resource object"},
 408     {"Processor",               "(ProcessorName, ProcessorID, PBlockAddress, PblockLength) {TermList}",
 409                                 "Declare a processor package"},
 410     {"QWordIo",                 "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
 411                                 "RangeTypeKeyword, AddressGranularity, "
 412                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
 413                                 "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
 414                                 "TranslationKeyword)",
 415                                 "QWord I/O Resource Descriptor macro"},
 416     {"QWordMemory",             "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, MaxKeyword, "
 417                                 "MemTypeKeyword, ReadWriteKeyword, "
 418                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 419                                 "RangeLength, ResourceSourceIndex, ResourceSource, "
 420                                 "DescriptorName, AddressKeyword, "
 421                                 "TypeKeyword)",
 422                                 "QWord Memory Resource Descriptor macro"},
 423     {"QWordSpace",              "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
 424                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
 425                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 426                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)",
 427                                 "Qword Space Resource Descriptor macro"},
 428     {"RawDataBuffer",           "(BufferSize) {ByteList} => RawDataBuffer",
 429                                 "Create a raw data buffer (does not use Buffer AML opcode)"},
 430     {"RefOf",                   "(Object) => ObjectReference",
 431                                 "Create Reference to an object"},
 432     {"Register",                "(AddressSpaceKeyword, RegisterBitWidth, "
 433                                 "RegisterBitOffset, RegisterAddress, "
 434                                 "AccessSize, DescriptorName)",
 435                                 "Generic register Resource Descriptor macro"},
 436     {"Release",                 "(SyncObject)",
 437                                 "Release a synchronization object"},
 438     {"Reset",                   "(SyncObject)",
 439                                 "Reset a synchronization object"},
 440     {"ResourceTemplate",        "() {ResourceMacroList} => Buffer",
 441                                 "Resource to buffer conversion macro"},
 442     {"Return",                  "None | () | (ReturnArg)",
 443                                 "Return from method execution"},
 444     {"Revision",                "=> Integer",
 445                                 "Constant revision object"},
 446     {"Scope",                   "(Location) {TermList}",
 447                                 "Open named scope "},
 448     {"ShiftLeft",               "(Source, ShiftCount, Result) => Integer",
 449                                 "Integer shift value left"},
 450     {"ShiftRight",              "(Source, ShiftCount, Result) => Integer",
 451                                 "Integer shift value right"},
 452     {"Signal",                  "(SyncObject)",
 453                                 "Signal a synchronization object"},
 454     {"SizeOf",                  "(ObjectName) => Integer",
 455                                 "Get the size of a buffer}, string}, or package"},
 456     {"Sleep",                   "(Milliseconds)",
 457                                 "Sleep n milliseconds (yields the processor)"},
 458     {"SpiSerialBusV2",          "(DeviceSelection, PolarityKeyword, WireModeKeyword, "
 459                                 "DataBitLength, SlaveModeKeyword, "
 460                                 "ConnectionSpeed, ClockPolarityKeyword, ClockPhaseKeyword, "
 461                                 "ResourceSource, ResourceSourceIndex, "
 462                                 "ResourceTypeKeyword, DescriptorName, Shared, RawDataBuffer() {VendorData})",
 463                                 "SPI Serial Bus Connection Resource Descriptor Macro"},
 464     {"Stall",                   "(Microseconds)",
 465                                 "Delay n microseconds (does not yield the processor)"},
 466     {"StartDependentFn",        "(CompatibilityPriority, PerformancePriority) {ResourceList}",
 467                                 "Start Dependent Function Resource Descriptor macro"},
 468     {"StartDependentFnNoPri",   "() {ResourceList}",
 469                                 "Start Dependent Function Resource Descriptor macro"},
 470     {"Store",                   "(Source, Destination) => DataRefObject",
 471                                 "Store object"},
 472     {"Subtract",                "(Minuend, Subtrahend, Result) => Integer",
 473                                 "Integer Subtract"},
 474     {"Switch",                  "(Expression) {CaseTermList}",
 475                                 "Select code to execute based on expression value"},
 476     {"ThermalZone",             "(ThermalZoneName) {TermList}",
 477                                 "Declare a thermal zone package"},
 478     {"Timer",                   "=> Integer",
 479                                 "Get 64-bit timer value"},
 480     {"ToBcd",                   "(Value, Result) => Integer",
 481                                 "Convert Integer to BCD"},
 482     {"ToBuffer",                "(Data, Result) => Buffer",
 483                                 "Convert data type to buffer"},
 484     {"ToDecimalString",         "(Data, Result) => String",
 485                                 "Convert data type to decimal string"},
 486     {"ToHexString",             "(Data, Result) => String",
 487                                 "Convert data type to hexadecimal string"},
 488     {"ToInteger",               "(Data, Result) => Integer",
 489                                 "Convert data type to integer"},
 490     {"ToString",                "(Source, Length, Result) => String",
 491                                 "Copy ASCII string from buffer"},
 492     {"ToUuid",                  "(AsciiString) => Buffer",
 493                                 "Convert Ascii string to UUID"},
 494     {"UartSerialBusV2",         "(ConnectionSpeed, ByteLengthKeyword, StopBitsKeyword, "
 495                                 "LinesInUse, EndianKeyword, ParityKeyword, "
 496                                 "FlowControlKeyword, ReceiveBufferSize, TransmitBufferSize, ResourceSource, "
 497                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, Shared, "
 498                                 "RawDataBuffer() {VendorData})",
 499                                 "UART Serial Bus Connection Resource Descriptor Macro"},
 500     {"Unicode",                 "(String) => Buffer",
 501                                 "String to Unicode conversion macro"},
 502     {"Unload",                  "(Handle)",
 503                                 "Unload definition block"},
 504     {"VendorLong",              "(DescriptorName) {VendorByteList}",
 505                                 "Vendor Resource Descriptor"},
 506     {"VendorShort",             "(DescriptorName) {VendorByteList}",
 507                                 "Vendor Resource Descriptor"},
 508     {"Wait",                    "(SyncObject, TimeoutValue) => Boolean",
 509                                 "Wait on an Event"},
 510     {"While",                   "(Predicate) {TermList}",
 511                                 "Conditional loop"},
 512     {"WordBusNumber",           "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
 513                                 "AddressGranularity, AddressMinimum, "
 514                                 "AddressMaximum, AddressTranslation, RangeLength, ResourceSourceIndex, "
 515                                 "ResourceSource, DescriptorName)",
 516                                 "Word Bus number Resource Descriptor macro"},
 517     {"WordIo",                  "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
 518                                 "RangeTypeKeyword, AddressGranularity, "
 519                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
 520                                 "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
 521                                 "TranslationKeyword)",
 522                                 "Word I/O Resource Descriptor macro"},
 523     {"WordSpace",               "(ResourceType, ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
 524                                 "MaxKeyword, TypeSpecificFlags, "
 525                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 526                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)",
 527                                 "Word Space Resource Descriptor macro"},
 528     {"Xor",                     "(Source1, Source2, Result) => Integer",
 529                                 "Integer Bitwise Xor"},
 530     {"Zero",                    "=> Integer",
 531                                 "Constant Zero object (0)"},
 532     {NULL, NULL, NULL}
 533 };