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  * 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 #include "acpihelp.h"
  45
  46 /*
  47  * ASL operators with syntax (directly from ACPI specification).
  48  * Note: All tokens require a space separator.
  49  * Long lines are automatically split during output.
  50  */
  51 const AH_ASL_OPERATOR       AslOperatorInfo[] =
  52 {
  53     {"AccessAs",                "(AccessType, AccessAttribKeyword | "
  54                                 "ExtendedAttribKeyword (AccessLength))",
  55                                 "ChangeFieldUnitAccess"},
  56     {"Acquire",                 "(SyncObject, TimeoutValue) => Boolean",
  57                                 "Acquire a mutex"},
  58     {"Add",                     "(Addend1, Addend2, Result) => Integer",
  59                                 "Integer Add"},
  60     {"Alias",                   "(SourceObject, AliasObject)",
  61                                 "Define a name alias"},
  62     {"And",                     "(Source1, Source2, Result) => Integer",
  63                                 "Integer Bitwise And"},
  64     {"Arg",                     "Arg0 - Arg6",
  65                                 "Method argument data objects"},
  66     {"BankField",               "(RegionName, BankName, BankValue, "
  67                                 "AccessTypeKeyword, LockRuleKeyword, "
  68                                 "UpdateRuleKeyword) {FieldUnitList}",
  69                                 "Declare fields in a banked configuration object"},
  70     {"Break",                   "No parameters",
  71                                 "Continue following the innermost enclosing While"},
  72     {"BreakPoint",              "No parameters",
  73                                 "Used for debugging, stops execution in the debugger"},
  74     {"Buffer",                  "(BufferSize) {String or ByteList} => Buffer",
  75                                 "Declare Buffer object"},
  76     {"Case",                    "(Value) {TermList}",
  77                                 "Expression for conditional execution"},
  78     {"Concatenate",             "(Source1, Source2, Result) => ComputationalData",
  79                                 "Concatenate two strings, integers or buffers"},
  80     {"ConcatenateResTemplate",  "(Source1, Source2, Result) => Buffer",
  81                                 "Concatenate two resource templates"},
  82     {"CondRefOf",               "(Source, Result) => Boolean",
  83                                 "Conditional reference to an object"},
  84     {"Connection",              "(ResourceMacro)",
  85                                 "Associate connection with FieldUnits within a Field object"},
  86     {"Continue",                "No parameters",
  87                                 "Continue innermost enclosing While loop"},
  88     {"CopyObject",              "(Source, Destination) => DataRefObject",
  89                                 "Copy and existing object"},
  90     {"CreateBitField",          "(SourceBuffer, BitIndex, BitFieldName)",
  91                                 "Declare a bit field object of a buffer object"},
  92     {"CreateByteField",         "(SourceBuffer, ByteIndex, ByteFieldName)",
  93                                 "Declare a byte field object of a buffer object"},
  94     {"CreateDWordField",        "(SourceBuffer, ByteIndex, DWordFieldName)",
  95                                 "Declare a DWord field object of a buffer object"},
  96     {"CreateField",             "(SourceBuffer, BitIndex, NumBits, FieldName)",
  97                                 "Declare an arbitrary length bit field of a buffer object"},
  98     {"CreateQWordField",        "(SourceBuffer, ByteIndex, QWordFieldName)",
  99                                 "Declare a QWord field object of a buffer object"},
 100     {"CreateWordField",         "(SourceBuffer, ByteIndex, WordFieldName)",
 101                                 "Declare a Word field object of a buffer object"},
 102     {"DataTableRegion",         "(RegionName, SignatureString, OemIDString, OemTableIDString)",
 103                                 "Declare a Data Table Region"},
 104     {"Debug",                   "No parameters",
 105                                 "Debugger output"},
 106     {"Decrement",               "(Minuend) => Integer",
 107                                 "Decrement an Integer"},
 108     {"Default",                 "{TermList}",
 109                                 "Default execution path in Switch()"},
 110     {"DefinitionBlock",         "(AmlFileName, TableSignature, ComplianceRevision, "
 111                                 "OemId, TableId, OemRevision) {TermList}",
 112                                 "Declare a Definition Block"},
 113     {"DerefOf",                 "(Source) => Object",
 114                                 "Dereference an object reference"},
 115     {"Device",                  "(DeviceName) {ObjectList}",
 116                                 "Declare a bus/device object"},
 117     {"Divide",                  "(Dividend, Divisor, Remainder, Result) => Integer",
 118                                 "Integer Divide"},
 119     {"DMA",                     "(DmaTypeKeyword, BusMasterKeyword, XferTypeKeyword, "
 120                                 "DescriptorName) {DmaChannelList} => Buffer",
 121                                 "DMA Resource Descriptor macro"},
 122     {"DWordIO",                 "(ResourceTypeKeyword, MinKeyword, MaxKeyword, "
 123                                 "DecodeKeyword, RangeTypeKeyword, AddressGranularity, "
 124                                 "AddressMinimum, AddressMaximum, AddressTranslation, "
 125                                 "RangeLength, ResourceSourceIndex, "
 126                                 "ResourceSource, DescriptorName, TypeKeyword, TranslationKeyword)",
 127                                 "DWord IO Resource Descriptor macro"},
 128     {"DWordMemory",             "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
 129                                 "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, "
 130                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 131                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName, AddressKeyword, "
 132                                 "TypeKeyword)",
 133                                 "DWord Memory Resource Descriptor macro"},
 134     {"DWordSpace",              "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
 135                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
 136                                 "AddressGranularity, AddressMinimum, AddressMaximum, "
 137                                 "AddressTranslation, RangeLength, "
 138                                 "ResourceSourceIndex, ResourceSource, DescriptorName)",
 139                                 "DWord Space Resource Descriptor macro"},
 140     {"EISAID",                  "(EisaIdString) => DWordConst",
 141                                 "EISA ID String to Integer conversion macro"},
 142     {"Else",                    "{TermList}",
 143                                 "Alternate conditional execution"},
 144     {"ElseIf",                  "(Predicate)",
 145                                 "Conditional execution"},
 146     {"EndDependentFn",          "() => Buffer",
 147                                 "End Dependent Function Resource Descriptor macro"},
 148     {"Event",                   "(EventName)",
 149                                 "Declare an event synchronization object"},
 150     {"ExtendedIO",              "(ResourceTypeKeyword, MinKeyword, MaxKeyword, "
 151                                 "DecodeKeyword, RangeTypeKeyword, AddressGranularity, "
 152                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
 153                                 "TypeSpecificAttributes, DescriptorName, TypeKeyword, TranslationKeyword)",
 154                                 "Extended IO Resource Descriptor macro"},
 155     {"ExtendedMemory",          "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
 156                                 "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, "
 157                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 158                                 "RangeLength, TypeSpecificAttributes, DescriptorName, "
 159                                 "AddressKeyword, TypeKeyword)",
 160                                 "Extended Memory Resource Descriptor macro"},
 161     {"ExtendedSpace",           "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
 162                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
 163                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 164                                 "RangeLength, TypeSpecificAttributes, DescriptorName)",
 165                                 "Extended Space Resource Descriptor macro"},
 166     {"External",                "(ObjectName, ObjectTypeKeyword, ReturnType, ParameterTypes)",
 167                                 "Declare external objects"},
 168     {"Fatal",                   "(Type, Code, Arg)",
 169                                 "Fatal error check"},
 170     {"Field",                   "(RegionName, AccessTypeKeyword, LockRuleKeyword, "
 171                                 "UpdateRuleKeyword) {FieldUnitList}",
 172                                 "Declare fields of an operation region object"},
 173     {"FindSetLeftBit",          "(Source, Result) => Integer",
 174                                 "Index of first least significant bit set"},
 175     {"FindSetRightBit",         "(Source, Result) => Integer",
 176                                 "Index of first most significant bit set"},
 177     {"FixedDMA",                "(DmaRequestLine, Channel, TransferWidthKeyword, DescriptorName) => Buffer",
 178                                 "Fixed DMA Resource Descriptor macro"},
 179     {"FixedIO",                 "(AddressBase, RangeLength, DescriptorName) => Buffer",
 180                                 "Fixed I/O Resource Descriptor macro"},
 181     {"FromBCD",                 "(BCDValue, Result) => Integer",
 182                                 "Convert from BCD to numeric"},
 183     {"Function",                "(FunctionName, ReturnType, ParameterTypes) {TermList}",
 184                                 "Declare control method"},
 185     {"GpioInt",                 "(InterruptTypeKeyword, InterruptLevelKeyword, "
 186                                 "ShareTypeKeyword, PinConfigKeyword, "
 187                                 "DebounceTimeout, ResourceSource, "
 188                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
 189                                 "RawDataBuffer() {VendorData}) {Pin}",
 190                                 "GPIO Interrupt Connection Resource Descriptor Macro"},
 191     {"GpioIo",                  "(ShareTypeKeyword, PinConfigKeyword, DebounceTimeout, DriveStrength, "
 192                                 "IoRestrictionKeyword, ResourceSource, "
 193                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
 194                                 "RawDataBuffer() {VendorData}) {PinList}",
 195                                 "GPIO I/O Connection Resource Descriptor Macro"},
 196     {"I2cSerialBus",            "(SlaveAddress, SlaveModeKeyword, ConnectionSpeed, "
 197                                 "AddressingModeKeyword, ResourceSource, "
 198                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
 199                                 "RawDataBuffer() {VendorData})",
 200                                 "I2C Serial Bus Connection Resource Descriptor Macro"},
 201     {"If",                      "(Predicate) {TermList}",
 202                                 "Conditional execution"},
 203     {"Include",                 "(FilePathName)",
 204                                 "Include another ASL file"},
 205     {"Increment",               "(Addend) => Integer",
 206                                 "Increment a Integer"},
 207     {"Index",                   "(Source, Index, Destination) => ObjectReference",
 208                                 "Indexed Reference to member object"},
 209     {"IndexField",              "(IndexName, DataName, AccessTypeKeyword, LockRuleKeyword, "
 210                                 "UpdateRuleKeyword) {FieldUnitList}",
 211                                 "Declare Index/Data Fields"},
 212     {"Interrupt",               "(ResourceTypeKeyword, InterruptTypeKeyword, InterruptLevelKeyword, "
 213                                 "ShareTypeKeyword, ResourceSourceIndex, "
 214                                 "ResourceSource, DescriptorName) {InterruptList} => Buffer",
 215                                 "Interrupt Resource Descriptor macro"},
 216     {"IO",                      "(IoDecodeKeyword, AddressMin, AddressMax, AddressAlignment, "
 217                                 "RangeLength, DescriptorName) => Buffer",
 218                                 "IO Resource Descriptor macro"},
 219     {"IRQ",                     "(InterruptTypeKeyword, InterruptLevelKeyword, ShareTypeKeyword, "
 220                                 "DescriptorName) {InterruptList} => Buffer",
 221                                 "Interrupt Resource Descriptor macro"},
 222     {"IRQNoFlags",              "(DescriptorName) {InterruptList} => Buffer",
 223                                 "Short Interrupt Resource Descriptor macro"},
 224     {"LAnd",                    "(Source1, Source2) => Boolean",
 225                                 "Logical And"},
 226     {"LEqual",                  "(Source1, Source2) => Boolean",
 227                                 "Logical Equal"},
 228     {"LGreater",                "(Source1, Source2) => Boolean",
 229                                 "Logical Greater"},
 230     {"LGreaterEqual",           "(Source1, Source2) => Boolean",
 231                                 "Logical Not less"},
 232     {"LLess",                   "(Source1, Source2) => Boolean",
 233                                 "Logical Less"},
 234     {"LLessEqual",              "(Source1, Source2) => Boolean",
 235                                 "Logical Not greater"},
 236     {"LNot",                    "(Source) => Boolean",
 237                                 "Logical Not"},
 238     {"LNotEqual",               "(Source1, Source2) => Boolean",
 239                                 "Logical Not equal"},
 240     {"Load",                    "(Object, DDBHandle)",
 241                                 "Load differentiating definition block"},
 242     {"LoadTable",               "(SignatureString, OemIdString, OemTableIdString, RootPathString, "
 243                                 "ParameterPathString, ParameterData) => DDBHandle",
 244                                 "Load Table from RSDT/XSDT"},
 245     {"Local",                   "Local0 - Local7",
 246                                 "Method local data objects"},
 247     {"LOr",                     "(Source1, Source2) => Boolean",
 248                                 "Logical Or"},
 249     {"Match",                   "(SearchPackage, MatchOpKeyword, MatchObject1, MatchOpKeyword, "
 250                                 "MatchObject2, StartIndex) => Ones | Integer",
 251                                 "Search for match in package array"},
 252     {"Memory24",                "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, "
 253                                 "RangeLength, DescriptorName)",
 254                                 "Memory Resource Descriptor macro"},
 255     {"Memory32",                "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, "
 256                                 "RangeLength, DescriptorName)",
 257                                 "Memory Resource Descriptor macro"},
 258     {"Memory32Fixed",           "(ReadWriteKeyword, AddressBase, RangeLength, DescriptorName)",
 259                                 "Memory Resource Descriptor macro"},
 260     {"Method",                  "(MethodName, NumArgs, SerializeRuleKeyword, "
 261                                 "SyncLevel, ReturnType, ParameterTypes) "
 262                                 "{TermList}",
 263                                 "Declare a control method"},
 264     {"Mid",                     "(Source, Index, Length, Result) => Buffer or String",
 265                                 "Return a portion of buffer or string"},
 266     {"Mod",                     "(Dividend, Divisor, Result) => Integer",
 267                                 "Integer Modulo"},
 268     {"Multiply",                "(Multiplicand, Multiplier, Result) => Integer",
 269                                 "Integer Multiply"},
 270     {"Mutex",                   "(MutexName, SyncLevel)",
 271                                 "Declare a mutex synchronization object"},
 272     {"Name",                    "(ObjectName, Object)",
 273                                 "Declare a Named object"},
 274     {"NAnd",                    "(Source1, Source2, Result) => Integer",
 275                                 "Integer Bitwise Nand"},
 276     {"NoOp",                    "No parameters",
 277                                 "No operation"},
 278     {"NOr",                     "(Source1, Source2, Result) => Integer",
 279                                 "Integer Bitwise Nor"},
 280     {"Not",                     "(Source, Result) => Integer",
 281                                 "Integer Bitwise Not"},
 282     {"Notify",                  "(Object, NotificationValue)",
 283                                 "Notify Object of event"},
 284     {"ObjectType",              "(Object) => Integer",
 285                                 "Type of object"},
 286     {"Offset",                  "(ByteOffset)",
 287                                 "Change Current Field Unit Offset"},
 288     {"One",                     "=> Integer",
 289                                 "Constant One Object (1)"},
 290     {"Ones",                    "=> Integer",
 291                                 "Constant Ones Object (0xFFFFFFFF or 0xFFFFFFFFFFFFFFFF)"},
 292     {"OperationRegion",         "(RegionName, RegionSpaceKeyword, Offset, Length)",
 293                                 "Declare an operational region"},
 294     {"Or",                      "(Source1, Source2, Result) => Integer",
 295                                 "Integer Bitwise Or"},
 296     {"Package",                 "(NumElements) {PackageList} => Package",
 297                                 "Declare a package object"},
 298     {"PowerResource",           "(ResourceName, SystemLevel, ResourceOrder) {ObjectList}",
 299                                 "Declare a power resource object"},
 300     {"Processor",               "(ProcessorName, ProcessorID, PBlockAddress, PblockLength) {ObjectList}",
 301                                 "Declare a processor package"},
 302     {"QWordIO",                 "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
 303                                 "RangeTypeKeyword, AddressGranularity, "
 304                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
 305                                 "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
 306                                 "TranslationKeyword)",
 307                                 "QWord IO Resource Descriptor macro"},
 308     {"QWordMemory",             "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, MaxKeyword, "
 309                                 "MemTypeKeyword, ReadWriteKeyword, "
 310                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 311                                 "RangeLength, ResourceSourceIndex, ResourceSource, "
 312                                 "DescriptorName, AddressKeyword, "
 313                                 "TypeKeyword)",
 314                                 "QWord Memory Resource Descriptor macro"},
 315     {"QWordSpace",              "(ResourceType, ResourceTypeKeyword, DecodeKeyword, "
 316                                 "MinKeyword, MaxKeyword, TypeSpecificFlags, "
 317                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 318                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)",
 319                                 "Qword Space Resource Descriptor macro"},
 320     {"RawDataBuffer",           "(BufferSize) {ByteList} => RawDataBuffer",
 321                                 "Create a raw data buffer (does not use Buffer AML opcode)"},
 322     {"RefOf",                   "(Object) => ObjectReference",
 323                                 "Create Reference to an object"},
 324     {"Register",                "(AddressSpaceKeyword, RegisterBitWidth, "
 325                                 "RegisterBitOffset, RegisterAddress, "
 326                                 "AccessSize, DescriptorName)",
 327                                 "Generic register Resource Descriptor macro"},
 328     {"Release",                 "(SyncObject)",
 329                                 "Release a synchronization object"},
 330     {"Reset",                   "(SyncObject)",
 331                                 "Reset a synchronization object"},
 332     {"ResourceTemplate",        "() {ResourceMacroList} => Buffer",
 333                                 "Resource to buffer conversion macro"},
 334     {"Return",                  "None | () | (ReturnArg)",
 335                                 "Return from method execution"},
 336     {"Revision",                "=> Integer",
 337                                 "Constant revision object"},
 338     {"Scope",                   "(Location) {ObjectList}",
 339                                 "Open named scope "},
 340     {"ShiftLeft",               "(Source, ShiftCount, Result) => Integer",
 341                                 "Integer shift value left"},
 342     {"ShiftRight",              "(Source, ShiftCount, Result) => Integer",
 343                                 "Integer shift value right"},
 344     {"Signal",                  "(SyncObject)",
 345                                 "Signal a synchronization object"},
 346     {"SizeOf",                  "(ObjectName) => Integer",
 347                                 "Get the size of a buffer}, string}, or package"},
 348     {"Sleep",                   "(Milliseconds)",
 349                                 "Sleep n milliseconds (yields the processor)"},
 350     {"SpiSerialBus",            "(DeviceSelection, PolarityKeyword, WireModeKeyword, "
 351                                 "DataBitLength, SlaveModeKeyword, "
 352                                 "ConnectionSpeed, ClockPolarityKeyword, ClockPhaseKeyword, "
 353                                 "ResourceSource, ResourceSourceIndex, "
 354                                 "ResourceTypeKeyword, DescriptorName, RawDataBuffer() {VendorData})",
 355                                 "SPI Serial Bus Connection Resource Descriptor Macro"},
 356     {"Stall",                   "(Microseconds)",
 357                                 "Delay n microseconds (does not yield the processor)"},
 358     {"StartDependentFn",        "(CompatibilityPriority, PerformancePriority) {ResourceList}",
 359                                 "Start Dependent Function Resource Descriptor macro"},
 360     {"StartDependentFnNoPri",   "() {ResourceList}",
 361                                 "Start Dependent Function Resource Descriptor macro"},
 362     {"Store",                   "(Source, Destination) => DataRefObject",
 363                                 "Store object"},
 364     {"Subtract",                "(Minuend, Subtrahend, Result) => Integer",
 365                                 "Integer Subtract"},
 366     {"Switch",                  "(Expression) {CaseTermList}",
 367                                 "Select code to execute based on expression value"},
 368     {"ThermalZone",             "(ThermalZoneName) {ObjectList}",
 369                                 "Declare a thermal zone package"},
 370     {"Timer",                   "=> Integer",
 371                                 "Get 64-bit timer value"},
 372     {"ToBCD",                   "(Value, Result) => Integer",
 373                                 "Convert Integer to BCD"},
 374     {"ToBuffer",                "(Data, Result) => Buffer",
 375                                 "Convert data type to buffer"},
 376     {"ToDecimalString",         "(Data, Result) => String",
 377                                 "Convert data type to decimal string"},
 378     {"ToHexString",             "(Data, Result) => String",
 379                                 "Convert data type to hexadecimal string"},
 380     {"ToInteger",               "(Data, Result) => Integer",
 381                                 "Convert data type to integer"},
 382     {"ToString",                "(Source, Length, Result) => String",
 383                                 "Copy ASCII string from buffer"},
 384     {"ToUUID",                  "(AsciiString) => Buffer",
 385                                 "Convert Ascii string to UUID"},
 386     {"UartSerialBus",           "(ConnectionSpeed, ByteLengthKeyword, StopBitsKeyword, "
 387                                 "LinesInUse, EndianKeyword, ParityKeyword, "
 388                                 "FlowControlKeyword, ReceiveBufferSize, TransmitBufferSize, ResourceSource, "
 389                                 "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
 390                                 "RawDataBuffer() {VendorData})",
 391                                 "UART Serial Bus Connection Resource Descriptor Macro"},
 392     {"Unicode",                 "(String) => Buffer",
 393                                 "String to Unicode conversion macro"},
 394     {"Unload",                  "(Handle)",
 395                                 "Unload definition block"},
 396     {"VendorLong",              "(DescriptorName) {VendorByteList}",
 397                                 "Vendor Resource Descriptor"},
 398     {"VendorShort",             "(DescriptorName) {VendorByteList}",
 399                                 "Vendor Resource Descriptor"},
 400     {"Wait",                    "(SyncObject, TimeoutValue) => Boolean",
 401                                 "Wait on an Event"},
 402     {"While",                   "(Predicate) {TermList}",
 403                                 "Conditional loop"},
 404     {"WordBusNumber",           "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
 405                                 "AddressGranularity, AddressMinimum, "
 406                                 "AddressMaximum, AddressTranslation, RangeLength, ResourceSourceIndex, "
 407                                 "ResourceSource, DescriptorName)",
 408                                 "Word Bus number Resource Descriptor macro"},
 409     {"WordIO",                  "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
 410                                 "RangeTypeKeyword, AddressGranularity, "
 411                                 "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
 412                                 "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
 413                                 "TranslationKeyword)",
 414                                 "Word IO Resource Descriptor macro"},
 415     {"WordSpace",               "(ResourceType, ResourceTypeKeyword, DecodeKeyword, MinKeyword, "
 416                                 "MaxKeyword, TypeSpecificFlags, "
 417                                 "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, "
 418                                 "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)",
 419                                 "Word Space Resource Descriptor macro"},
 420     {"XOr",                     "(Source1, Source2, Result) => Integer",
 421                                 "Integer Bitwise Xor"},
 422     {"Zero",                    "=> Integer",
 423                                 "Constant Zero object (0)"},
 424     {NULL, NULL, NULL}
 425 };