/****************************************************************************** * * Module Name: ahaslops - Table of all known ASL operators * *****************************************************************************/ /****************************************************************************** * * 1. Copyright Notice * * Some or all of this work - Copyright (c) 1999 - 2023, Intel Corp. * All rights reserved. * * 2. License * * 2.1. This is your license from Intel Corp. under its intellectual property * rights. You may have additional license terms from the party that provided * you this software, covering your right to use that party's intellectual * property rights. * * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a * copy of the source code appearing in this file ("Covered Code") an * irrevocable, perpetual, worldwide license under Intel's copyrights in the * base code distributed originally by Intel ("Original Intel Code") to copy, * make derivatives, distribute, use and display any portion of the Covered * Code in any form, with the right to sublicense such rights; and * * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent * license (with the right to sublicense), under only those claims of Intel * patents that are infringed by the Original Intel Code, to make, use, sell, * offer to sell, and import the Covered Code and derivative works thereof * solely to the minimum extent necessary to exercise the above copyright * license, and in no event shall the patent license extend to any additions * to or modifications of the Original Intel Code. No other license or right * is granted directly or by implication, estoppel or otherwise; * * The above copyright and patent license is granted only if the following * conditions are met: * * 3. Conditions * * 3.1. Redistribution of Source with Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification with rights to further distribute source must include * the above Copyright Notice, the above License, this list of Conditions, * and the following Disclaimer and Export Compliance provision. In addition, * Licensee must cause all Covered Code to which Licensee contributes to * contain a file documenting the changes Licensee made to create that Covered * Code and the date of any change. Licensee must include in that file the * documentation of any changes made by any predecessor Licensee. Licensee * must include a prominent statement that the modification is derived, * directly or indirectly, from Original Intel Code. * * 3.2. Redistribution of Source with no Rights to Further Distribute Source. * Redistribution of source code of any substantial portion of the Covered * Code or modification without rights to further distribute source must * include the following Disclaimer and Export Compliance provision in the * documentation and/or other materials provided with distribution. In * addition, Licensee may not authorize further sublicense of source of any * portion of the Covered Code, and must include terms to the effect that the * license from Licensee to its licensee is limited to the intellectual * property embodied in the software Licensee provides to its licensee, and * not to intellectual property embodied in modifications its licensee may * make. * * 3.3. Redistribution of Executable. Redistribution in executable form of any * substantial portion of the Covered Code or modification must reproduce the * above Copyright Notice, and the following Disclaimer and Export Compliance * provision in the documentation and/or other materials provided with the * distribution. * * 3.4. Intel retains all right, title, and interest in and to the Original * Intel Code. * * 3.5. Neither the name Intel nor any other trademark owned or controlled by * Intel shall be used in advertising or otherwise to promote the sale, use or * other dealings in products derived from or relating to the Covered Code * without prior written authorization from Intel. * * 4. Disclaimer and Export Compliance * * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A * PARTICULAR PURPOSE. * * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY * LIMITED REMEDY. * * 4.3. Licensee shall not export, either directly or indirectly, any of this * software or system incorporating such software without first obtaining any * required license or other approval from the U. S. Department of Commerce or * any other agency or department of the United States Government. In the * event Licensee exports any such software from the United States or * re-exports any such software from a foreign destination, Licensee shall * ensure that the distribution and export/re-export of the software is in * compliance with all laws, regulations, orders, or other restrictions of the * U.S. Export Administration Regulations. Licensee agrees that neither it nor * any of its subsidiaries will export/re-export any technical data, process, * software, or service, directly or indirectly, to any country for which the * United States government or any agency thereof requires an export license, * other governmental approval, or letter of assurance, without first obtaining * such license, approval or letter. * ***************************************************************************** * * Alternatively, you may choose to be licensed under the terms of the * following license: * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions, and the following disclaimer, * without modification. * 2. Redistributions in binary form must reproduce at minimum a disclaimer * substantially similar to the "NO WARRANTY" disclaimer below * ("Disclaimer") and any redistribution must be conditioned upon * including a substantially similar Disclaimer requirement for further * binary redistribution. * 3. Neither the names of the above-listed copyright holders nor the names * of any contributors may be used to endorse or promote products derived * from this software without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * * Alternatively, you may choose to be licensed under the terms of the * GNU General Public License ("GPL") version 2 as published by the Free * Software Foundation. * *****************************************************************************/ #include "acpihelp.h" /* * ASL operators with syntax (directly from ACPI specification). * Note: All tokens require a space separator. * Long lines are automatically split during output. */ const AH_ASL_OPERATOR Gbl_AslOperatorInfo[] = { {"AccessAs", "(AccessType, AccessAttribKeyword | " "ExtendedAttribKeyword (AccessLength))", "ChangeFieldUnitAccess"}, {"Acquire", "(SyncObject, TimeoutValue) => Boolean", "Acquire a mutex"}, {"Add", "(Addend1, Addend2, Result) => Integer", "Integer Add"}, {"Alias", "(SourceObject, AliasObject)", "Define a name alias"}, {"And", "(Source1, Source2, Result) => Integer", "Integer Bitwise And"}, {"Arg", "Arg0 - Arg6", "Method argument data objects"}, {"BankField", "(RegionName, BankName, BankValue, " "AccessTypeKeyword, LockRuleKeyword, " "UpdateRuleKeyword) {FieldUnitList}", "Declare fields in a banked configuration object"}, {"Break", "No parameters", "Continue following the innermost enclosing While"}, {"BreakPoint", "No parameters", "Used for debugging, stops execution in the debugger"}, {"Buffer", "(BufferSize) {String or ByteList} => Buffer", "Declare Buffer object"}, {"Case", "(Value) {TermList}", "Expression for conditional execution"}, {"Concatenate", "(Source1, Source2, Result) => ComputationalData", "Concatenate two strings, integers or buffers"}, {"ConcatenateResTemplate", "(Source1, Source2, Result) => Buffer", "Concatenate two resource templates"}, {"CondRefOf", "(Source, Result) => Boolean", "Conditional reference to an object"}, {"Connection", "(ResourceMacro)", "Associate connection with FieldUnits within a Field object"}, {"Continue", "No parameters", "Continue innermost enclosing While loop"}, {"CopyObject", "(Source, Destination) => DataRefObject", "Copy and existing object"}, {"CreateBitField", "(SourceBuffer, BitIndex, BitFieldName)", "Declare a bit field object of a buffer object"}, {"CreateByteField", "(SourceBuffer, ByteIndex, ByteFieldName)", "Declare a byte field object of a buffer object"}, {"CreateDWordField", "(SourceBuffer, ByteIndex, DWordFieldName)", "Declare a DWord field object of a buffer object"}, {"CreateField", "(SourceBuffer, BitIndex, NumBits, FieldName)", "Declare an arbitrary length bit field of a buffer object"}, {"CreateQWordField", "(SourceBuffer, ByteIndex, QWordFieldName)", "Declare a QWord field object of a buffer object"}, {"CreateWordField", "(SourceBuffer, ByteIndex, WordFieldName)", "Declare a Word field object of a buffer object"}, {"DataTableRegion", "(RegionName, SignatureString, OemIDString, OemTableIDString)", "Declare a Data Table Region"}, {"Debug", "No parameters", "Debugger output"}, {"Decrement", "(Minuend) => Integer", "Decrement an Integer"}, {"Default", "{TermList}", "Default execution path in Switch()"}, {"DefinitionBlock", "(AmlFileName, TableSignature, ComplianceRevision, " "OemId, TableId, OemRevision) {TermList}", "Declare a Definition Block"}, {"DerefOf", "(Source) => Object", "Dereference an object reference"}, {"Device", "(DeviceName) {TermList}", "Declare a bus/device object"}, {"Divide", "(Dividend, Divisor, Remainder, Result) => Integer", "Integer Divide"}, {"Dma", "(DmaTypeKeyword, BusMasterKeyword, XferTypeKeyword, " "DescriptorName) {DmaChannelList} => Buffer", "DMA Resource Descriptor macro"}, {"DWordIo", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, " "DecodeKeyword, RangeTypeKeyword, AddressGranularity, " "AddressMinimum, AddressMaximum, AddressTranslation, " "RangeLength, ResourceSourceIndex, " "ResourceSource, DescriptorName, TypeKeyword, TranslationKeyword)", "DWord I/O Resource Descriptor macro"}, {"DWordMemory", "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, " "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, " "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, " "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName, AddressKeyword, " "TypeKeyword)", "DWord Memory Resource Descriptor macro"}, {"DWordSpace", "(ResourceType, ResourceTypeKeyword, DecodeKeyword, " "MinKeyword, MaxKeyword, TypeSpecificFlags, " "AddressGranularity, AddressMinimum, AddressMaximum, " "AddressTranslation, RangeLength, " "ResourceSourceIndex, ResourceSource, DescriptorName)", "DWord Space Resource Descriptor macro"}, {"EisaId", "(EisaIdString) => DWordConst", "EISA ID String to Integer conversion macro"}, {"Else", "{TermList}", "Alternate conditional execution"}, {"ElseIf", "(Predicate)", "Conditional execution"}, {"EndDependentFn", "() => Buffer", "End Dependent Function Resource Descriptor macro"}, {"Event", "(EventName)", "Declare an event synchronization object"}, {"ExtendedIo", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, " "DecodeKeyword, RangeTypeKeyword, AddressGranularity, " "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, " "TypeSpecificAttributes, DescriptorName, TypeKeyword, TranslationKeyword)", "Extended I/O Resource Descriptor macro"}, {"ExtendedMemory", "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, " "MaxKeyword, MemTypeKeyword, ReadWriteKeyword, " "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, " "RangeLength, TypeSpecificAttributes, DescriptorName, " "AddressKeyword, TypeKeyword)", "Extended Memory Resource Descriptor macro"}, {"ExtendedSpace", "(ResourceType, ResourceTypeKeyword, DecodeKeyword, " "MinKeyword, MaxKeyword, TypeSpecificFlags, " "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, " "RangeLength, TypeSpecificAttributes, DescriptorName)", "Extended Space Resource Descriptor macro"}, {"External", "(ObjectName, ObjectTypeKeyword, ReturnType, ParameterTypes)", "Declare external objects"}, {"Fatal", "(Type, Code, Arg)", "Fatal error check"}, {"Field", "(RegionName, AccessTypeKeyword, LockRuleKeyword, " "UpdateRuleKeyword) {FieldUnitList}", "Declare fields of an operation region object"}, {"FindSetLeftBit", "(Source, Result) => Integer", "Index of first least significant bit set"}, {"FindSetRightBit", "(Source, Result) => Integer", "Index of first most significant bit set"}, {"FixedDma", "(DmaRequestLine, Channel, TransferWidthKeyword, DescriptorName) => Buffer", "Fixed DMA Resource Descriptor macro"}, {"FixedIo", "(AddressBase, RangeLength, DescriptorName) => Buffer", "Fixed I/O Resource Descriptor macro"}, {"FromBcd", "(BcdValue, Result) => Integer", "Convert from BCD to numeric"}, {"Function", "(FunctionName, ReturnType, ParameterTypes) {TermList}", "Declare control method"}, {"GpioInt", "(InterruptTypeKeyword, InterruptLevelKeyword, " "ShareTypeKeyword, PinConfigKeyword, " "DebounceTimeout, ResourceSource, " "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, " "RawDataBuffer() {VendorData}) {Pin}", "GPIO Interrupt Connection Resource Descriptor Macro"}, {"GpioIo", "(ShareTypeKeyword, PinConfigKeyword, DebounceTimeout, DriveStrength, " "IoRestrictionKeyword, ResourceSource, " "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, " "RawDataBuffer() {VendorData}) {PinList}", "GPIO I/O Connection Resource Descriptor Macro"}, {"I2cSerialBusV2", "(SlaveAddress, SlaveModeKeyword, ConnectionSpeed, " "AddressingModeKeyword, ResourceSource, " "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, Shared, " "RawDataBuffer() {VendorData})", "I2C Serial Bus Connection Resource Descriptor Macro"}, {"If", "(Predicate) {TermList}", "Conditional execution"}, {"Include", "(FilePathName)", "Include another ASL file"}, {"Increment", "(Addend) => Integer", "Increment a Integer"}, {"Index", "(Source, Index, Destination) => ObjectReference", "Indexed Reference to member object"}, {"IndexField", "(IndexName, DataName, AccessTypeKeyword, LockRuleKeyword, " "UpdateRuleKeyword) {FieldUnitList}", "Declare Index/Data Fields"}, {"Interrupt", "(ResourceTypeKeyword, InterruptTypeKeyword, InterruptLevelKeyword, " "ShareTypeKeyword, ResourceSourceIndex, " "ResourceSource, DescriptorName) {InterruptList} => Buffer", "Interrupt Resource Descriptor macro"}, {"Io", "(IoDecodeKeyword, AddressMin, AddressMax, AddressAlignment, " "RangeLength, DescriptorName) => Buffer", "I/O Resource Descriptor macro"}, {"Irq", "(InterruptTypeKeyword, InterruptLevelKeyword, ShareTypeKeyword, " "DescriptorName) {InterruptList} => Buffer", "Interrupt Resource Descriptor macro"}, {"IrqNoFlags", "(DescriptorName) {InterruptList} => Buffer", "Short Interrupt Resource Descriptor macro"}, {"LAnd", "(Source1, Source2) => Boolean", "Logical And"}, {"LEqual", "(Source1, Source2) => Boolean", "Logical Equal"}, {"LGreater", "(Source1, Source2) => Boolean", "Logical Greater"}, {"LGreaterEqual", "(Source1, Source2) => Boolean", "Logical Not less"}, {"LLess", "(Source1, Source2) => Boolean", "Logical Less"}, {"LLessEqual", "(Source1, Source2) => Boolean", "Logical Not greater"}, {"LNot", "(Source) => Boolean", "Logical Not"}, {"LNotEqual", "(Source1, Source2) => Boolean", "Logical Not equal"}, {"Load", "(Object, DDBHandle)", "Load differentiating definition block"}, {"LoadTable", "(SignatureString, OemIdString, OemTableIdString, RootPathString, " "ParameterPathString, ParameterData) => DDBHandle", "Load Table from RSDT/XSDT"}, {"Local", "Local0 - Local7", "Method local data objects"}, {"LOr", "(Source1, Source2) => Boolean", "Logical Or"}, {"Match", "(SearchPackage, MatchOpKeyword, MatchObject1, MatchOpKeyword, " "MatchObject2, StartIndex) => Ones | Integer", "Search for match in package array"}, {"Memory24", "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, " "RangeLength, DescriptorName)", "Memory Resource Descriptor macro"}, {"Memory32", "(ReadWriteKeyword, AddressMinimum, AddressMaximum, AddressAlignment, " "RangeLength, DescriptorName)", "Memory Resource Descriptor macro"}, {"Memory32Fixed", "(ReadWriteKeyword, AddressBase, RangeLength, DescriptorName)", "Memory Resource Descriptor macro"}, {"Method", "(MethodName, NumArgs, SerializeRuleKeyword, " "SyncLevel, ReturnType, ParameterTypes) " "{TermList}", "Declare a control method"}, {"Mid", "(Source, Index, Length, Result) => Buffer or String", "Return a portion of buffer or string"}, {"Mod", "(Dividend, Divisor, Result) => Integer", "Integer Modulo"}, {"Multiply", "(Multiplicand, Multiplier, Result) => Integer", "Integer Multiply"}, {"Mutex", "(MutexName, SyncLevel)", "Declare a mutex synchronization object"}, {"Name", "(ObjectName, Object)", "Declare a Named object"}, {"NAnd", "(Source1, Source2, Result) => Integer", "Integer Bitwise Nand"}, {"NoOp", "No parameters", "No operation"}, {"NOr", "(Source1, Source2, Result) => Integer", "Integer Bitwise Nor"}, {"Not", "(Source, Result) => Integer", "Integer Bitwise Not"}, {"Notify", "(Object, NotificationValue)", "Notify Object of event"}, {"ObjectType", "(Object) => Integer", "Type of object"}, {"Offset", "(ByteOffset)", "Change Current Field Unit Offset"}, {"One", "=> Integer", "Constant One Object (1)"}, {"Ones", "=> Integer", "Constant Ones Object (0xFFFFFFFF or 0xFFFFFFFFFFFFFFFF)"}, {"OperationRegion", "(RegionName, RegionSpaceKeyword, Offset, Length)", "Declare an operational region"}, {"Or", "(Source1, Source2, Result) => Integer", "Integer Bitwise Or"}, {"Package", "(NumElements) {PackageList} => Package", "Declare a package object"}, {"PowerResource", "(ResourceName, SystemLevel, ResourceOrder) {TermList}", "Declare a power resource object"}, {"Processor", "(ProcessorName, ProcessorID, PBlockAddress, PblockLength) {TermList}", "Declare a processor package"}, {"QWordIo", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, " "RangeTypeKeyword, AddressGranularity, " "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, " "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, " "TranslationKeyword)", "QWord I/O Resource Descriptor macro"}, {"QWordMemory", "(ResourceTypeKeyword, DecodeKeyword, MinKeyword, MaxKeyword, " "MemTypeKeyword, ReadWriteKeyword, " "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, " "RangeLength, ResourceSourceIndex, ResourceSource, " "DescriptorName, AddressKeyword, " "TypeKeyword)", "QWord Memory Resource Descriptor macro"}, {"QWordSpace", "(ResourceType, ResourceTypeKeyword, DecodeKeyword, " "MinKeyword, MaxKeyword, TypeSpecificFlags, " "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, " "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)", "Qword Space Resource Descriptor macro"}, {"RawDataBuffer", "(BufferSize) {ByteList} => RawDataBuffer", "Create a raw data buffer (does not use Buffer AML opcode)"}, {"RefOf", "(Object) => ObjectReference", "Create Reference to an object"}, {"Register", "(AddressSpaceKeyword, RegisterBitWidth, " "RegisterBitOffset, RegisterAddress, " "AccessSize, DescriptorName)", "Generic register Resource Descriptor macro"}, {"Release", "(SyncObject)", "Release a synchronization object"}, {"Reset", "(SyncObject)", "Reset a synchronization object"}, {"ResourceTemplate", "() {ResourceMacroList} => Buffer", "Resource to buffer conversion macro"}, {"Return", "None | () | (ReturnArg)", "Return from method execution"}, {"Revision", "=> Integer", "Constant revision object"}, {"Scope", "(Location) {TermList}", "Open named scope "}, {"ShiftLeft", "(Source, ShiftCount, Result) => Integer", "Integer shift value left"}, {"ShiftRight", "(Source, ShiftCount, Result) => Integer", "Integer shift value right"}, {"Signal", "(SyncObject)", "Signal a synchronization object"}, {"SizeOf", "(ObjectName) => Integer", "Get the size of a buffer}, string}, or package"}, {"Sleep", "(Milliseconds)", "Sleep n milliseconds (yields the processor)"}, {"SpiSerialBusV2", "(DeviceSelection, PolarityKeyword, WireModeKeyword, " "DataBitLength, SlaveModeKeyword, " "ConnectionSpeed, ClockPolarityKeyword, ClockPhaseKeyword, " "ResourceSource, ResourceSourceIndex, " "ResourceTypeKeyword, DescriptorName, Shared, RawDataBuffer() {VendorData})", "SPI Serial Bus Connection Resource Descriptor Macro"}, {"Stall", "(Microseconds)", "Delay n microseconds (does not yield the processor)"}, {"StartDependentFn", "(CompatibilityPriority, PerformancePriority) {ResourceList}", "Start Dependent Function Resource Descriptor macro"}, {"StartDependentFnNoPri", "() {ResourceList}", "Start Dependent Function Resource Descriptor macro"}, {"Store", "(Source, Destination) => DataRefObject", "Store object"}, {"Subtract", "(Minuend, Subtrahend, Result) => Integer", "Integer Subtract"}, {"Switch", "(Expression) {CaseTermList}", "Select code to execute based on expression value"}, {"ThermalZone", "(ThermalZoneName) {TermList}", "Declare a thermal zone package"}, {"Timer", "=> Integer", "Get 64-bit timer value"}, {"ToBcd", "(Value, Result) => Integer", "Convert Integer to BCD"}, {"ToBuffer", "(Data, Result) => Buffer", "Convert data type to buffer"}, {"ToDecimalString", "(Data, Result) => String", "Convert data type to decimal string"}, {"ToHexString", "(Data, Result) => String", "Convert data type to hexadecimal string"}, {"ToInteger", "(Data, Result) => Integer", "Convert data type to integer"}, {"ToString", "(Source, Length, Result) => String", "Copy ASCII string from buffer"}, {"ToUuid", "(AsciiString) => Buffer", "Convert Ascii string to UUID"}, {"UartSerialBusV2", "(ConnectionSpeed, ByteLengthKeyword, StopBitsKeyword, " "LinesInUse, EndianKeyword, ParityKeyword, " "FlowControlKeyword, ReceiveBufferSize, TransmitBufferSize, ResourceSource, " "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, Shared, " "RawDataBuffer() {VendorData})", "UART Serial Bus Connection Resource Descriptor Macro"}, {"Unicode", "(String) => Buffer", "String to Unicode conversion macro"}, {"Unload", "(Handle)", "Unload definition block"}, {"VendorLong", "(DescriptorName) {VendorByteList}", "Vendor Resource Descriptor"}, {"VendorShort", "(DescriptorName) {VendorByteList}", "Vendor Resource Descriptor"}, {"Wait", "(SyncObject, TimeoutValue) => Boolean", "Wait on an Event"}, {"While", "(Predicate) {TermList}", "Conditional loop"}, {"WordBusNumber", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, " "AddressGranularity, AddressMinimum, " "AddressMaximum, AddressTranslation, RangeLength, ResourceSourceIndex, " "ResourceSource, DescriptorName)", "Word Bus number Resource Descriptor macro"}, {"WordIo", "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, " "RangeTypeKeyword, AddressGranularity, " "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, " "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, " "TranslationKeyword)", "Word I/O Resource Descriptor macro"}, {"WordSpace", "(ResourceType, ResourceTypeKeyword, DecodeKeyword, MinKeyword, " "MaxKeyword, TypeSpecificFlags, " "AddressGranularity, AddressMinimum, AddressMaximum, AddressTranslation, " "RangeLength, ResourceSourceIndex, ResourceSource, DescriptorName)", "Word Space Resource Descriptor macro"}, {"Xor", "(Source1, Source2, Result) => Integer", "Integer Bitwise Xor"}, {"Zero", "=> Integer", "Constant Zero object (0)"}, {NULL, NULL, NULL} };