--- /dev/null	ven. janv. 17 07:31:16 2014
+++ new/usr/src/common/acpica/tools/acpihelp/ahaslops.c	ven. janv. 17 07:31:16 2014
@@ -0,0 +1,425 @@
+/******************************************************************************
+ *
+ * Module Name: ahaslops - Table of all known ASL operators
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2014, Intel Corp.
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * Alternatively, this software may be distributed under the terms of the
+ * GNU General Public License ("GPL") version 2 as published by the Free
+ * Software Foundation.
+ *
+ * NO WARRANTY
+ * 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 MERCHANTIBILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * HOLDERS OR CONTRIBUTORS BE LIABLE FOR 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 DAMAGES.
+ */
+
+#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       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) {ObjectList}",
+                                "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 IO 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 IO 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"},
+    {"I2cSerialBus",            "(SlaveAddress, SlaveModeKeyword, ConnectionSpeed, "
+                                "AddressingModeKeyword, ResourceSource, "
+                                "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
+                                "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",
+                                "IO 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) {ObjectList}",
+                                "Declare a power resource object"},
+    {"Processor",               "(ProcessorName, ProcessorID, PBlockAddress, PblockLength) {ObjectList}",
+                                "Declare a processor package"},
+    {"QWordIO",                 "(ResourceTypeKeyword, MinKeyword, MaxKeyword, DecodeKeyword, "
+                                "RangeTypeKeyword, AddressGranularity, "
+                                "AddressMinimum, AddressMaximum, AddressTranslation, RangeLength, "
+                                "ResourceSourceIndex, ResourceSource, DescriptorName, TypeKeyword, "
+                                "TranslationKeyword)",
+                                "QWord IO 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) {ObjectList}",
+                                "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)"},
+    {"SpiSerialBus",            "(DeviceSelection, PolarityKeyword, WireModeKeyword, "
+                                "DataBitLength, SlaveModeKeyword, "
+                                "ConnectionSpeed, ClockPolarityKeyword, ClockPhaseKeyword, "
+                                "ResourceSource, ResourceSourceIndex, "
+                                "ResourceTypeKeyword, DescriptorName, 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) {ObjectList}",
+                                "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"},
+    {"UartSerialBus",           "(ConnectionSpeed, ByteLengthKeyword, StopBitsKeyword, "
+                                "LinesInUse, EndianKeyword, ParityKeyword, "
+                                "FlowControlKeyword, ReceiveBufferSize, TransmitBufferSize, ResourceSource, "
+                                "ResourceSourceIndex, ResourceTypeKeyword, DescriptorName, "
+                                "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 IO 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}
+};
