1 /******************************************************************************
3 * Module Name: ahaslops - Table of all known ASL operators
5 *****************************************************************************/
7 /******************************************************************************
11 * Some or all of this work - Copyright (c) 1999 - 2018, Intel Corp.
12 * All rights reserved.
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
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
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;
37 * The above copyright and patent license is granted only if the following
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.
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
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
72 * 3.4. Intel retains all right, title, and interest in and to the Original
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.
80 * 4. Disclaimer and Export Compliance
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
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
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.
114 *****************************************************************************
116 * Alternatively, you may choose to be licensed under the terms of the
119 * Redistribution and use in source and binary forms, with or without
120 * modification, are permitted provided that the following conditions
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.
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.
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.
150 *****************************************************************************/
152 #include "acpihelp.h"
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.
159 const AH_ASL_OPERATOR Gbl_AslOperatorInfo
[] =
161 {"AccessAs", "(AccessType, AccessAttribKeyword | "
162 "ExtendedAttribKeyword (AccessLength))",
163 "ChangeFieldUnitAccess"},
164 {"Acquire", "(SyncObject, TimeoutValue) => Boolean",
166 {"Add", "(Addend1, Addend2, Result) => Integer",
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",
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",
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, "
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",
334 {"LEqual", "(Source1, Source2) => Boolean",
336 {"LGreater", "(Source1, Source2) => Boolean",
338 {"LGreaterEqual", "(Source1, Source2) => Boolean",
340 {"LLess", "(Source1, Source2) => Boolean",
342 {"LLessEqual", "(Source1, Source2) => Boolean",
343 "Logical Not greater"},
344 {"LNot", "(Source) => Boolean",
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",
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) "
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",
376 {"Multiply", "(Multiplicand, Multiplier, Result) => Integer",
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",
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",
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, "
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",
472 {"Subtract", "(Minuend, Subtrahend, Result) => Integer",
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",
510 {"While", "(Predicate) {TermList}",
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)"},