1
2 %{
3 /******************************************************************************
4 *
5 * Module Name: aslcompiler.y - Bison input file (ASL grammar and actions)
6 *
7 *****************************************************************************/
8
9 /*
10 * Copyright (C) 2000 - 2011, Intel Corp.
11 * All rights reserved.
12 *
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
15 * are met:
16 * 1. Redistributions of source code must retain the above copyright
17 * notice, this list of conditions, and the following disclaimer,
18 * without modification.
19 * 2. Redistributions in binary form must reproduce at minimum a disclaimer
20 * substantially similar to the "NO WARRANTY" disclaimer below
21 * ("Disclaimer") and any redistribution must be conditioned upon
22 * including a substantially similar Disclaimer requirement for further
23 * binary redistribution.
24 * 3. Neither the names of the above-listed copyright holders nor the names
25 * of any contributors may be used to endorse or promote products derived
26 * from this software without specific prior written permission.
27 *
28 * Alternatively, this software may be distributed under the terms of the
29 * GNU General Public License ("GPL") version 2 as published by the Free
30 * Software Foundation.
31 *
32 * NO WARRANTY
33 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
34 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
35 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
36 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
37 * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
38 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
39 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
40 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
41 * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
42 * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
43 * POSSIBILITY OF SUCH DAMAGES.
44 */
45
46 #include <contrib/dev/acpica/compiler/aslcompiler.h>
47 #include <stdio.h>
48 #include <stdlib.h>
49 #include <string.h>
50 #include <contrib/dev/acpica/include/acpi.h>
51 #include <contrib/dev/acpica/include/accommon.h>
52
53 #define _COMPONENT ACPI_COMPILER
54 ACPI_MODULE_NAME ("aslparse")
55
56 /*
57 * Global Notes:
58 *
59 * October 2005: The following list terms have been optimized (from the
60 * original ASL grammar in the ACPI specification) to force the immediate
61 * reduction of each list item so that the parse stack use doesn't increase on
62 * each list element and possibly overflow on very large lists (>4000 items).
63 * This dramatically reduces use of the parse stack overall.
64 *
65 * ArgList, TermList, Objectlist, ByteList, DWordList, PackageList,
66 * ResourceMacroList, and FieldUnitList
67 */
68
69 void * AslLocalAllocate (unsigned int Size);
70
71 /* Bison/yacc configuration */
72
73 #define static
74 #undef alloca
75 #define alloca AslLocalAllocate
76 #define yytname AslCompilername
77
78 #define YYINITDEPTH 600 /* State stack depth */
79 #define YYDEBUG 1 /* Enable debug output */
80 #define YYERROR_VERBOSE 1 /* Verbose error messages */
81
82 /*
83 * The windows version of bison defines this incorrectly as "32768" (Not negative).
84 * We use a custom (edited binary) version of bison that defines YYFLAG as YYFBAD
85 * instead (#define YYFBAD 32768), so we can define it correctly here.
86 *
87 * The problem is that if YYFLAG is positive, the extended syntax error messages
88 * are disabled.
89 */
90 #define YYFLAG -32768
91
92 %}
93
94 /*
95 * Declare the type of values in the grammar
96 */
97 %union {
98 UINT64 i;
99 char *s;
100 ACPI_PARSE_OBJECT *n;
101 }
102
103 /*! [Begin] no source code translation */
104
105 /*
106 * These shift/reduce conflicts are expected. There should be zero
107 * reduce/reduce conflicts.
108 */
109 %expect 60
110
111 /*
112 * Token types: These are returned by the lexer
113 *
114 * NOTE: This list MUST match the AslKeywordMapping table found
115 * in aslmap.c EXACTLY! Double check any changes!
116 */
117 %token <i> PARSEOP_ACCESSAS
118 %token <i> PARSEOP_ACCESSATTRIB_BLOCK
119 %token <i> PARSEOP_ACCESSATTRIB_BLOCK_CALL
120 %token <i> PARSEOP_ACCESSATTRIB_BYTE
121 %token <i> PARSEOP_ACCESSATTRIB_WORD_CALL
122 %token <i> PARSEOP_ACCESSATTRIB_QUICK
123 %token <i> PARSEOP_ACCESSATTRIB_SND_RCV
124 %token <i> PARSEOP_ACCESSATTRIB_WORD
125 %token <i> PARSEOP_ACCESSTYPE_ANY
126 %token <i> PARSEOP_ACCESSTYPE_BUF
127 %token <i> PARSEOP_ACCESSTYPE_BYTE
128 %token <i> PARSEOP_ACCESSTYPE_DWORD
129 %token <i> PARSEOP_ACCESSTYPE_QWORD
130 %token <i> PARSEOP_ACCESSTYPE_WORD
131 %token <i> PARSEOP_ACQUIRE
132 %token <i> PARSEOP_ADD
133 %token <i> PARSEOP_ADDRESSSPACE_FFIXEDHW
134 %token <i> PARSEOP_ADDRESSTYPE_ACPI
135 %token <i> PARSEOP_ADDRESSTYPE_MEMORY
136 %token <i> PARSEOP_ADDRESSTYPE_NVS
137 %token <i> PARSEOP_ADDRESSTYPE_RESERVED
138 %token <i> PARSEOP_ALIAS
139 %token <i> PARSEOP_AND
140 %token <i> PARSEOP_ARG0
141 %token <i> PARSEOP_ARG1
142 %token <i> PARSEOP_ARG2
143 %token <i> PARSEOP_ARG3
144 %token <i> PARSEOP_ARG4
145 %token <i> PARSEOP_ARG5
146 %token <i> PARSEOP_ARG6
147 %token <i> PARSEOP_BANKFIELD
148 %token <i> PARSEOP_BREAK
149 %token <i> PARSEOP_BREAKPOINT
150 %token <i> PARSEOP_BUFFER
151 %token <i> PARSEOP_BUSMASTERTYPE_MASTER
152 %token <i> PARSEOP_BUSMASTERTYPE_NOTMASTER
153 %token <i> PARSEOP_BYTECONST
154 %token <i> PARSEOP_CASE
155 %token <i> PARSEOP_CONCATENATE
156 %token <i> PARSEOP_CONCATENATERESTEMPLATE
157 %token <i> PARSEOP_CONDREFOF
158 %token <i> PARSEOP_CONTINUE
159 %token <i> PARSEOP_COPYOBJECT
160 %token <i> PARSEOP_CREATEBITFIELD
161 %token <i> PARSEOP_CREATEBYTEFIELD
162 %token <i> PARSEOP_CREATEDWORDFIELD
163 %token <i> PARSEOP_CREATEFIELD
164 %token <i> PARSEOP_CREATEQWORDFIELD
165 %token <i> PARSEOP_CREATEWORDFIELD
166 %token <i> PARSEOP_DATATABLEREGION
167 %token <i> PARSEOP_DEBUG
168 %token <i> PARSEOP_DECODETYPE_POS
169 %token <i> PARSEOP_DECODETYPE_SUB
170 %token <i> PARSEOP_DECREMENT
171 %token <i> PARSEOP_DEFAULT
172 %token <i> PARSEOP_DEFAULT_ARG
173 %token <i> PARSEOP_DEFINITIONBLOCK
174 %token <i> PARSEOP_DEREFOF
175 %token <i> PARSEOP_DEVICE
176 %token <i> PARSEOP_DIVIDE
177 %token <i> PARSEOP_DMA
178 %token <i> PARSEOP_DMATYPE_A
179 %token <i> PARSEOP_DMATYPE_COMPATIBILITY
180 %token <i> PARSEOP_DMATYPE_B
181 %token <i> PARSEOP_DMATYPE_F
182 %token <i> PARSEOP_DWORDCONST
183 %token <i> PARSEOP_DWORDIO
184 %token <i> PARSEOP_DWORDMEMORY
185 %token <i> PARSEOP_DWORDSPACE
186 %token <i> PARSEOP_EISAID
187 %token <i> PARSEOP_ELSE
188 %token <i> PARSEOP_ELSEIF
189 %token <i> PARSEOP_ENDDEPENDENTFN
190 %token <i> PARSEOP_ENDTAG
191 %token <i> PARSEOP_ERRORNODE
192 %token <i> PARSEOP_EVENT
193 %token <i> PARSEOP_EXTENDEDIO
194 %token <i> PARSEOP_EXTENDEDMEMORY
195 %token <i> PARSEOP_EXTENDEDSPACE
196 %token <i> PARSEOP_EXTERNAL
197 %token <i> PARSEOP_FATAL
198 %token <i> PARSEOP_FIELD
199 %token <i> PARSEOP_FINDSETLEFTBIT
200 %token <i> PARSEOP_FINDSETRIGHTBIT
201 %token <i> PARSEOP_FIXEDIO
202 %token <i> PARSEOP_FROMBCD
203 %token <i> PARSEOP_FUNCTION
204 %token <i> PARSEOP_IF
205 %token <i> PARSEOP_INCLUDE
206 %token <i> PARSEOP_INCLUDE_CSTYLE
207 %token <i> PARSEOP_INCLUDE_END
208 %token <i> PARSEOP_INCREMENT
209 %token <i> PARSEOP_INDEX
210 %token <i> PARSEOP_INDEXFIELD
211 %token <i> PARSEOP_INTEGER
212 %token <i> PARSEOP_INTERRUPT
213 %token <i> PARSEOP_INTLEVEL_ACTIVEHIGH
214 %token <i> PARSEOP_INTLEVEL_ACTIVELOW
215 %token <i> PARSEOP_INTTYPE_EDGE
216 %token <i> PARSEOP_INTTYPE_LEVEL
217 %token <i> PARSEOP_IO
218 %token <i> PARSEOP_IODECODETYPE_10
219 %token <i> PARSEOP_IODECODETYPE_16
220 %token <i> PARSEOP_IRQ
221 %token <i> PARSEOP_IRQNOFLAGS
222 %token <i> PARSEOP_LAND
223 %token <i> PARSEOP_LEQUAL
224 %token <i> PARSEOP_LGREATER
225 %token <i> PARSEOP_LGREATEREQUAL
226 %token <i> PARSEOP_LINE_CSTYLE
227 %token <i> PARSEOP_LLESS
228 %token <i> PARSEOP_LLESSEQUAL
229 %token <i> PARSEOP_LNOT
230 %token <i> PARSEOP_LNOTEQUAL
231 %token <i> PARSEOP_LOAD
232 %token <i> PARSEOP_LOADTABLE
233 %token <i> PARSEOP_LOCAL0
234 %token <i> PARSEOP_LOCAL1
235 %token <i> PARSEOP_LOCAL2
236 %token <i> PARSEOP_LOCAL3
237 %token <i> PARSEOP_LOCAL4
238 %token <i> PARSEOP_LOCAL5
239 %token <i> PARSEOP_LOCAL6
240 %token <i> PARSEOP_LOCAL7
241 %token <i> PARSEOP_LOCKRULE_LOCK
242 %token <i> PARSEOP_LOCKRULE_NOLOCK
243 %token <i> PARSEOP_LOR
244 %token <i> PARSEOP_MATCH
245 %token <i> PARSEOP_MATCHTYPE_MEQ
246 %token <i> PARSEOP_MATCHTYPE_MGE
247 %token <i> PARSEOP_MATCHTYPE_MGT
248 %token <i> PARSEOP_MATCHTYPE_MLE
249 %token <i> PARSEOP_MATCHTYPE_MLT
250 %token <i> PARSEOP_MATCHTYPE_MTR
251 %token <i> PARSEOP_MAXTYPE_FIXED
252 %token <i> PARSEOP_MAXTYPE_NOTFIXED
253 %token <i> PARSEOP_MEMORY24
254 %token <i> PARSEOP_MEMORY32
255 %token <i> PARSEOP_MEMORY32FIXED
256 %token <i> PARSEOP_MEMTYPE_CACHEABLE
257 %token <i> PARSEOP_MEMTYPE_NONCACHEABLE
258 %token <i> PARSEOP_MEMTYPE_PREFETCHABLE
259 %token <i> PARSEOP_MEMTYPE_WRITECOMBINING
260 %token <i> PARSEOP_METHOD
261 %token <i> PARSEOP_METHODCALL
262 %token <i> PARSEOP_MID
263 %token <i> PARSEOP_MINTYPE_FIXED
264 %token <i> PARSEOP_MINTYPE_NOTFIXED
265 %token <i> PARSEOP_MOD
266 %token <i> PARSEOP_MULTIPLY
267 %token <i> PARSEOP_MUTEX
268 %token <i> PARSEOP_NAME
269 %token <s> PARSEOP_NAMESEG
270 %token <s> PARSEOP_NAMESTRING
271 %token <i> PARSEOP_NAND
272 %token <i> PARSEOP_NOOP
273 %token <i> PARSEOP_NOR
274 %token <i> PARSEOP_NOT
275 %token <i> PARSEOP_NOTIFY
276 %token <i> PARSEOP_OBJECTTYPE
277 %token <i> PARSEOP_OBJECTTYPE_BFF
278 %token <i> PARSEOP_OBJECTTYPE_BUF
279 %token <i> PARSEOP_OBJECTTYPE_DDB
280 %token <i> PARSEOP_OBJECTTYPE_DEV
281 %token <i> PARSEOP_OBJECTTYPE_EVT
282 %token <i> PARSEOP_OBJECTTYPE_FLD
283 %token <i> PARSEOP_OBJECTTYPE_INT
284 %token <i> PARSEOP_OBJECTTYPE_MTH
285 %token <i> PARSEOP_OBJECTTYPE_MTX
286 %token <i> PARSEOP_OBJECTTYPE_OPR
287 %token <i> PARSEOP_OBJECTTYPE_PKG
288 %token <i> PARSEOP_OBJECTTYPE_POW
289 %token <i> PARSEOP_OBJECTTYPE_PRO
290 %token <i> PARSEOP_OBJECTTYPE_STR
291 %token <i> PARSEOP_OBJECTTYPE_THZ
292 %token <i> PARSEOP_OBJECTTYPE_UNK
293 %token <i> PARSEOP_OFFSET
294 %token <i> PARSEOP_ONE
295 %token <i> PARSEOP_ONES
296 %token <i> PARSEOP_OPERATIONREGION
297 %token <i> PARSEOP_OR
298 %token <i> PARSEOP_PACKAGE
299 %token <i> PARSEOP_PACKAGE_LENGTH
300 %token <i> PARSEOP_POWERRESOURCE
301 %token <i> PARSEOP_PROCESSOR
302 %token <i> PARSEOP_QWORDCONST
303 %token <i> PARSEOP_QWORDIO
304 %token <i> PARSEOP_QWORDMEMORY
305 %token <i> PARSEOP_QWORDSPACE
306 %token <i> PARSEOP_RANGETYPE_ENTIRE
307 %token <i> PARSEOP_RANGETYPE_ISAONLY
308 %token <i> PARSEOP_RANGETYPE_NONISAONLY
309 %token <i> PARSEOP_RAW_DATA
310 %token <i> PARSEOP_READWRITETYPE_BOTH
311 %token <i> PARSEOP_READWRITETYPE_READONLY
312 %token <i> PARSEOP_REFOF
313 %token <i> PARSEOP_REGIONSPACE_CMOS
314 %token <i> PARSEOP_REGIONSPACE_EC
315 %token <i> PARSEOP_REGIONSPACE_IO
316 %token <i> PARSEOP_REGIONSPACE_IPMI
317 %token <i> PARSEOP_REGIONSPACE_MEM
318 %token <i> PARSEOP_REGIONSPACE_PCI
319 %token <i> PARSEOP_REGIONSPACE_PCIBAR
320 %token <i> PARSEOP_REGIONSPACE_SMBUS
321 %token <i> PARSEOP_REGISTER
322 %token <i> PARSEOP_RELEASE
323 %token <i> PARSEOP_RESERVED_BYTES
324 %token <i> PARSEOP_RESET
325 %token <i> PARSEOP_RESOURCETEMPLATE
326 %token <i> PARSEOP_RESOURCETYPE_CONSUMER
327 %token <i> PARSEOP_RESOURCETYPE_PRODUCER
328 %token <i> PARSEOP_RETURN
329 %token <i> PARSEOP_REVISION
330 %token <i> PARSEOP_SCOPE
331 %token <i> PARSEOP_SERIALIZERULE_NOTSERIAL
332 %token <i> PARSEOP_SERIALIZERULE_SERIAL
333 %token <i> PARSEOP_SHARETYPE_EXCLUSIVE
334 %token <i> PARSEOP_SHARETYPE_SHARED
335 %token <i> PARSEOP_SHIFTLEFT
336 %token <i> PARSEOP_SHIFTRIGHT
337 %token <i> PARSEOP_SIGNAL
338 %token <i> PARSEOP_SIZEOF
339 %token <i> PARSEOP_SLEEP
340 %token <i> PARSEOP_STALL
341 %token <i> PARSEOP_STARTDEPENDENTFN
342 %token <i> PARSEOP_STARTDEPENDENTFN_NOPRI
343 %token <i> PARSEOP_STORE
344 %token <s> PARSEOP_STRING_LITERAL
345 %token <i> PARSEOP_SUBTRACT
346 %token <i> PARSEOP_SWITCH
347 %token <i> PARSEOP_THERMALZONE
348 %token <i> PARSEOP_TIMER
349 %token <i> PARSEOP_TOBCD
350 %token <i> PARSEOP_TOBUFFER
351 %token <i> PARSEOP_TODECIMALSTRING
352 %token <i> PARSEOP_TOHEXSTRING
353 %token <i> PARSEOP_TOINTEGER
354 %token <i> PARSEOP_TOSTRING
355 %token <i> PARSEOP_TOUUID
356 %token <i> PARSEOP_TRANSLATIONTYPE_DENSE
357 %token <i> PARSEOP_TRANSLATIONTYPE_SPARSE
358 %token <i> PARSEOP_TYPE_STATIC
359 %token <i> PARSEOP_TYPE_TRANSLATION
360 %token <i> PARSEOP_UNICODE
361 %token <i> PARSEOP_UNLOAD
362 %token <i> PARSEOP_UPDATERULE_ONES
363 %token <i> PARSEOP_UPDATERULE_PRESERVE
364 %token <i> PARSEOP_UPDATERULE_ZEROS
365 %token <i> PARSEOP_VAR_PACKAGE
366 %token <i> PARSEOP_VENDORLONG
367 %token <i> PARSEOP_VENDORSHORT
368 %token <i> PARSEOP_WAIT
369 %token <i> PARSEOP_WHILE
370 %token <i> PARSEOP_WORDBUSNUMBER
371 %token <i> PARSEOP_WORDCONST
372 %token <i> PARSEOP_WORDIO
373 %token <i> PARSEOP_WORDSPACE
374 %token <i> PARSEOP_XFERTYPE_8
375 %token <i> PARSEOP_XFERTYPE_8_16
376 %token <i> PARSEOP_XFERTYPE_16
377 %token <i> PARSEOP_XOR
378 %token <i> PARSEOP_ZERO
379
380 /*
381 * Special functions. These should probably stay at the end of this
382 * table.
383 */
384 %token <i> PARSEOP___DATE__
385 %token <i> PARSEOP___FILE__
386 %token <i> PARSEOP___LINE__
387
388 /*
389 * Production names
390 */
391
392 %type <n> ASLCode
393 %type <n> DefinitionBlockTerm
394 %type <n> TermList
395 %type <n> Term
396 %type <n> CompilerDirective
397 %type <n> ObjectList
398 %type <n> Object
399 %type <n> DataObject
400 %type <n> BufferData
401 %type <n> PackageData
402 %type <n> IntegerData
403 %type <n> StringData
404 %type <n> NamedObject
405 %type <n> NameSpaceModifier
406 %type <n> UserTerm
407 %type <n> ArgList
408 %type <n> TermArg
409 %type <n> Target
410 %type <n> RequiredTarget
411 %type <n> SimpleTarget
412 %type <n> BufferTermData
413 %type <n> ParameterTypePackage
414 %type <n> ParameterTypePackageList
415 %type <n> ParameterTypesPackage
416 %type <n> ParameterTypesPackageList
417
418 %type <n> Type1Opcode
419 %type <n> Type2Opcode
420 %type <n> Type2IntegerOpcode
421 %type <n> Type2StringOpcode
422 %type <n> Type2BufferOpcode
423 %type <n> Type2BufferOrStringOpcode
424 %type <n> Type3Opcode
425
426 /* Obsolete %type <n> Type4Opcode */
427
428 %type <n> Type5Opcode
429 %type <n> Type6Opcode
430
431 %type <n> LineTerm
432 %type <n> IncludeTerm
433 %type <n> IncludeCStyleTerm
434 %type <n> ExternalTerm
435
436 %type <n> FieldUnitList
437 %type <n> FieldUnit
438 %type <n> FieldUnitEntry
439
440 %type <n> OffsetTerm
441 %type <n> AccessAsTerm
442 %type <n> OptionalAccessAttribTerm
443
444
445 /* Named Objects */
446
447 %type <n> BankFieldTerm
448 %type <n> CreateBitFieldTerm
449 %type <n> CreateByteFieldTerm
450 %type <n> CreateDWordFieldTerm
451 %type <n> CreateFieldTerm
452 %type <n> CreateQWordFieldTerm
453 %type <n> CreateWordFieldTerm
454 %type <n> DataRegionTerm
455 %type <n> DeviceTerm
456 %type <n> EventTerm
457 %type <n> FieldTerm
458 %type <n> FunctionTerm
459 %type <n> IndexFieldTerm
460 %type <n> MethodTerm
461 %type <n> MutexTerm
462 %type <n> OpRegionTerm
463 %type <n> OpRegionSpaceIdTerm
464 %type <n> PowerResTerm
465 %type <n> ProcessorTerm
466 %type <n> ThermalZoneTerm
467
468
469 /* Namespace modifiers */
470
471 %type <n> AliasTerm
472 %type <n> NameTerm
473 %type <n> ScopeTerm
474
475 /* Type 1 opcodes */
476
477 %type <n> BreakTerm
478 %type <n> BreakPointTerm
479 %type <n> ContinueTerm
480 %type <n> FatalTerm
481 %type <n> IfElseTerm
482 %type <n> IfTerm
483 %type <n> ElseTerm
484 %type <n> LoadTerm
485 %type <n> NoOpTerm
486 %type <n> NotifyTerm
487 %type <n> ReleaseTerm
488 %type <n> ResetTerm
489 %type <n> ReturnTerm
490 %type <n> SignalTerm
491 %type <n> SleepTerm
492 %type <n> StallTerm
493 %type <n> SwitchTerm
494 %type <n> CaseDefaultTermList
495 //%type <n> CaseTermList
496 %type <n> CaseTerm
497 %type <n> DefaultTerm
498 %type <n> UnloadTerm
499 %type <n> WhileTerm
500
501 /* Type 2 opcodes */
502
503 %type <n> AcquireTerm
504 %type <n> AddTerm
505 %type <n> AndTerm
506 %type <n> ConcatTerm
507 %type <n> ConcatResTerm
508 %type <n> CondRefOfTerm
509 %type <n> CopyObjectTerm
510 %type <n> DecTerm
511 %type <n> DerefOfTerm
512 %type <n> DivideTerm
513 %type <n> FindSetLeftBitTerm
514 %type <n> FindSetRightBitTerm
515 %type <n> FromBCDTerm
516 %type <n> IncTerm
517 %type <n> IndexTerm
518 %type <n> LAndTerm
519 %type <n> LEqualTerm
520 %type <n> LGreaterTerm
521 %type <n> LGreaterEqualTerm
522 %type <n> LLessTerm
523 %type <n> LLessEqualTerm
524 %type <n> LNotTerm
525 %type <n> LNotEqualTerm
526 %type <n> LoadTableTerm
527 %type <n> LOrTerm
528 %type <n> MatchTerm
529 %type <n> MidTerm
530 %type <n> ModTerm
531 %type <n> MultiplyTerm
532 %type <n> NAndTerm
533 %type <n> NOrTerm
534 %type <n> NotTerm
535 %type <n> ObjectTypeTerm
536 %type <n> OrTerm
537 %type <n> RefOfTerm
538 %type <n> ShiftLeftTerm
539 %type <n> ShiftRightTerm
540 %type <n> SizeOfTerm
541 %type <n> StoreTerm
542 %type <n> SubtractTerm
543 %type <n> TimerTerm
544 %type <n> ToBCDTerm
545 %type <n> ToBufferTerm
546 %type <n> ToDecimalStringTerm
547 %type <n> ToHexStringTerm
548 %type <n> ToIntegerTerm
549 %type <n> ToStringTerm
550 %type <n> WaitTerm
551 %type <n> XOrTerm
552
553 %type <n> OptionalTermArg
554 %type <n> OptionalReturnArg
555 %type <n> OptionalListString
556
557
558 /* Keywords */
559
560 %type <n> ObjectTypeKeyword
561 %type <n> AccessTypeKeyword
562 %type <n> AccessAttribKeyword
563 %type <n> LockRuleKeyword
564 %type <n> UpdateRuleKeyword
565 %type <n> RegionSpaceKeyword
566 %type <n> AddressSpaceKeyword
567 %type <n> MatchOpKeyword
568 %type <n> SerializeRuleKeyword
569 %type <n> DMATypeKeyword
570 %type <n> OptionalBusMasterKeyword
571 %type <n> XferTypeKeyword
572 %type <n> ResourceTypeKeyword
573 %type <n> MinKeyword
574 %type <n> MaxKeyword
575 %type <n> DecodeKeyword
576 %type <n> RangeTypeKeyword
577 %type <n> MemTypeKeyword
578 %type <n> OptionalReadWriteKeyword
579 %type <n> InterruptTypeKeyword
580 %type <n> InterruptLevel
581 %type <n> ShareTypeKeyword
582 %type <n> IODecodeKeyword
583 %type <n> TypeKeyword
584 %type <n> TranslationKeyword
585 %type <n> AddressKeyword
586
587 /* Types */
588
589 %type <n> SuperName
590 %type <n> ArgTerm
591 %type <n> LocalTerm
592 %type <n> DebugTerm
593
594 %type <n> Integer
595 %type <n> ByteConst
596 %type <n> WordConst
597 %type <n> DWordConst
598 %type <n> QWordConst
599 %type <n> String
600
601 %type <n> ConstTerm
602 %type <n> ByteConstExpr
603 %type <n> WordConstExpr
604 %type <n> DWordConstExpr
605 %type <n> QWordConstExpr
606 %type <n> ConstExprTerm
607
608 %type <n> BufferTerm
609 %type <n> ByteList
610 %type <n> DWordList
611
612 %type <n> PackageTerm
613 %type <n> PackageList
614 %type <n> PackageElement
615
616 %type <n> VarPackageLengthTerm
617
618 /* Macros */
619
620 %type <n> EISAIDTerm
621 %type <n> ResourceTemplateTerm
622 %type <n> ToUUIDTerm
623 %type <n> UnicodeTerm
624 %type <n> ResourceMacroList
625 %type <n> ResourceMacroTerm
626
627 %type <n> DMATerm
628 %type <n> DWordIOTerm
629 %type <n> DWordMemoryTerm
630 %type <n> DWordSpaceTerm
631 %type <n> EndDependentFnTerm
632 %type <n> ExtendedIOTerm
633 %type <n> ExtendedMemoryTerm
634 %type <n> ExtendedSpaceTerm
635 %type <n> FixedIOTerm
636 %type <n> InterruptTerm
637 %type <n> IOTerm
638 %type <n> IRQNoFlagsTerm
639 %type <n> IRQTerm
640 %type <n> Memory24Term
641 %type <n> Memory32FixedTerm
642 %type <n> Memory32Term
643 %type <n> QWordIOTerm
644 %type <n> QWordMemoryTerm
645 %type <n> QWordSpaceTerm
646 %type <n> RegisterTerm
647 %type <n> StartDependentFnTerm
648 %type <n> StartDependentFnNoPriTerm
649 %type <n> VendorLongTerm
650 %type <n> VendorShortTerm
651 %type <n> WordBusNumberTerm
652 %type <n> WordIOTerm
653 %type <n> WordSpaceTerm
654
655 %type <n> NameString
656 %type <n> NameSeg
657
658
659 /* Local types that help construct the AML, not in ACPI spec */
660
661 %type <n> IncludeEndTerm
662 %type <n> AmlPackageLengthTerm
663 %type <n> OptionalByteConstExpr
664 %type <n> OptionalDWordConstExpr
665 %type <n> OptionalQWordConstExpr
666 %type <n> OptionalSerializeRuleKeyword
667 %type <n> OptionalResourceType_First
668 %type <n> OptionalResourceType
669 %type <n> OptionalMinType
670 %type <n> OptionalMaxType
671 %type <n> OptionalMemType
672 %type <n> OptionalCount
673 %type <n> OptionalDecodeType
674 %type <n> OptionalRangeType
675 %type <n> OptionalShareType
676 %type <n> OptionalType
677 %type <n> OptionalType_Last
678 %type <n> OptionalTranslationType_Last
679 %type <n> OptionalStringData
680 %type <n> OptionalNameString
681 %type <n> OptionalNameString_First
682 %type <n> OptionalNameString_Last
683 %type <n> OptionalAddressRange
684 %type <n> OptionalObjectTypeKeyword
685 %type <n> OptionalParameterTypePackage
686 %type <n> OptionalParameterTypesPackage
687 %type <n> OptionalReference
688 %type <n> OptionalAccessSize
689
690 %type <n> TermArgItem
691 %type <n> NameStringItem
692
693 %%
694
695
696 /*******************************************************************************
697 *
698 * Production rules start here
699 *
700 ******************************************************************************/
701
702 /*
703 * ASL Names
704 */
705
706
707 /*
708 * Blocks, Data, and Opcodes
709 */
710
711 ASLCode
712 : DefinitionBlockTerm
713 | error {YYABORT; $$ = NULL;}
714 ;
715
716 /*
717 * Note concerning support for "module-level code".
718 *
719 * ACPI 1.0 allowed Type1 and Type2 executable opcodes outside of control
720 * methods (the so-called module-level code.) This support was explicitly
721 * removed in ACPI 2.0, but this type of code continues to be created by
722 * BIOS vendors. In order to support the disassembly and recompilation of
723 * such code (and the porting of ASL code to iASL), iASL supports this
724 * code in violation of the current ACPI specification.
725 *
726 * The grammar change to support module-level code is to revert the
727 * {ObjectList} portion of the DefinitionBlockTerm in ACPI 2.0 to the
728 * original use of {TermList} instead (see below.) This allows the use
729 * of Type1 and Type2 opcodes at module level.
730 */
731 DefinitionBlockTerm
732 : PARSEOP_DEFINITIONBLOCK '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITIONBLOCK);}
733 String ','
734 String ','
735 ByteConst ','
736 String ','
737 String ','
738 DWordConst
739 ')' {TrSetEndLineNumber ($<n>3);}
740 '{' TermList '}' {$$ = TrLinkChildren ($<n>3,7,$4,$6,$8,$10,$12,$14,$18);}
741 ;
742
743 /* ACPI 3.0 -- allow semicolons between terms */
744
745 TermList
746 : {$$ = NULL;}
747 | TermList Term {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$2);}
748 | TermList ';' Term {$$ = TrLinkPeerNode (TrSetNodeFlags ($1, NODE_RESULT_NOT_USED),$3);}
749 ;
750
751 Term
752 : Object {}
753 | Type1Opcode {}
754 | Type2Opcode {}
755 | Type2IntegerOpcode {}
756 | Type2StringOpcode {}
757 | Type2BufferOpcode {}
758 | Type2BufferOrStringOpcode {}
759 | error {$$ = AslDoError(); yyclearin;}
760 ;
761
762 CompilerDirective
763 : IncludeTerm {}
764 | IncludeCStyleTerm {$$ = NULL;}
765 | LineTerm {$$ = NULL;}
766 | ExternalTerm {}
767 ;
768
769 ObjectList
770 : {$$ = NULL;}
771 | ObjectList Object {$$ = TrLinkPeerNode ($1,$2);}
772 | error {$$ = AslDoError(); yyclearin;}
773 ;
774
775 Object
776 : CompilerDirective {}
777 | NamedObject {}
778 | NameSpaceModifier {}
779 ;
780
781 DataObject
782 : BufferData {}
783 | PackageData {}
784 | IntegerData {}
785 | StringData {}
786 ;
787
788 BufferData
789 : Type5Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
790 | Type2BufferOrStringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
791 | Type2BufferOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
792 | BufferTerm {}
793 ;
794
795 PackageData
796 : PackageTerm {}
797 ;
798
799 IntegerData
800 : Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
801 | Type3Opcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
802 | Integer {}
803 | ConstTerm {}
804 ;
805
806 StringData
807 : Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_COMPILE_TIME_CONST);}
808 | String {}
809 ;
810
811 NamedObject
812 : BankFieldTerm {}
813 | CreateBitFieldTerm {}
814 | CreateByteFieldTerm {}
815 | CreateDWordFieldTerm {}
816 | CreateFieldTerm {}
817 | CreateQWordFieldTerm {}
818 | CreateWordFieldTerm {}
819 | DataRegionTerm {}
820 | DeviceTerm {}
821 | EventTerm {}
822 | FieldTerm {}
823 | FunctionTerm {}
824 | IndexFieldTerm {}
825 | MethodTerm {}
826 | MutexTerm {}
827 | OpRegionTerm {}
828 | PowerResTerm {}
829 | ProcessorTerm {}
830 | ThermalZoneTerm {}
831 ;
832
833 NameSpaceModifier
834 : AliasTerm {}
835 | NameTerm {}
836 | ScopeTerm {}
837 ;
838
839 UserTerm
840 : NameString '(' {TrUpdateNode (PARSEOP_METHODCALL, $1);}
841 ArgList ')' {$$ = TrLinkChildNode ($1,$4);}
842 ;
843
844 ArgList
845 : {$$ = NULL;}
846 | TermArg
847 | ArgList ',' /* Allows a trailing comma at list end */
848 | ArgList ','
849 TermArg {$$ = TrLinkPeerNode ($1,$3);}
850 ;
851
852 /*
853 Removed from TermArg due to reduce/reduce conflicts
854 | Type2IntegerOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
855 | Type2StringOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
856 | Type2BufferOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
857 | Type2BufferOrStringOpcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
858
859 */
860
861 TermArg
862 : Type2Opcode {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
863 | DataObject {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
864 | NameString {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
865 | ArgTerm {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
866 | LocalTerm {$$ = TrSetNodeFlags ($1, NODE_IS_TERM_ARG);}
867 ;
868
869 Target
870 : {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_TARGET | NODE_COMPILE_TIME_CONST);} /* Placeholder is a ZeroOp object */
871 | ',' {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_TARGET | NODE_COMPILE_TIME_CONST);} /* Placeholder is a ZeroOp object */
872 | ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
873 ;
874
875 RequiredTarget
876 : ',' SuperName {$$ = TrSetNodeFlags ($2, NODE_IS_TARGET);}
877 ;
878
879 SimpleTarget
880 : NameString {}
881 | LocalTerm {}
882 | ArgTerm {}
883 ;
884
885 /* Rules for specifying the type of one method argument or return value */
886
887 ParameterTypePackage
888 : {$$ = NULL;}
889 | ObjectTypeKeyword {$$ = $1;}
890 | ParameterTypePackage ','
891 ObjectTypeKeyword {$$ = TrLinkPeerNodes (2,$1,$3);}
892 ;
893
894 ParameterTypePackageList
895 : {$$ = NULL;}
896 | ObjectTypeKeyword {$$ = $1;}
897 | '{' ParameterTypePackage '}' {$$ = $2;}
898 ;
899
900 OptionalParameterTypePackage
901 : {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
902 | ',' ParameterTypePackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
903 ;
904
905 /* Rules for specifying the types for method arguments */
906
907 ParameterTypesPackage
908 : ParameterTypePackageList {$$ = $1;}
909 | ParameterTypesPackage ','
910 ParameterTypePackageList {$$ = TrLinkPeerNodes (2,$1,$3);}
911 ;
912
913 ParameterTypesPackageList
914 : {$$ = NULL;}
915 | ObjectTypeKeyword {$$ = $1;}
916 | '{' ParameterTypesPackage '}' {$$ = $2;}
917 ;
918
919 OptionalParameterTypesPackage
920 : {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
921 | ',' ParameterTypesPackageList {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_DEFAULT_ARG),1,$2);}
922 ;
923
924
925 /* Opcode types */
926
927 Type1Opcode
928 : BreakTerm {}
929 | BreakPointTerm {}
930 | ContinueTerm {}
931 | FatalTerm {}
932 | IfElseTerm {}
933 | LoadTerm {}
934 | NoOpTerm {}
935 | NotifyTerm {}
936 | ReleaseTerm {}
937 | ResetTerm {}
938 | ReturnTerm {}
939 | SignalTerm {}
940 | SleepTerm {}
941 | StallTerm {}
942 | SwitchTerm {}
943 | UnloadTerm {}
944 | WhileTerm {}
945 ;
946
947 Type2Opcode
948 : AcquireTerm {}
949 | CondRefOfTerm {}
950 | CopyObjectTerm {}
951 | DerefOfTerm {}
952 | ObjectTypeTerm {}
953 | RefOfTerm {}
954 | SizeOfTerm {}
955 | StoreTerm {}
956 | TimerTerm {}
957 | WaitTerm {}
958 | UserTerm {}
959 ;
960
961 /*
962 * Type 3/4/5 opcodes
963 */
964
965 Type2IntegerOpcode /* "Type3" opcodes */
966 : AddTerm {}
967 | AndTerm {}
968 | DecTerm {}
969 | DivideTerm {}
970 | FindSetLeftBitTerm {}
971 | FindSetRightBitTerm {}
972 | FromBCDTerm {}
973 | IncTerm {}
974 | IndexTerm {}
975 | LAndTerm {}
976 | LEqualTerm {}
977 | LGreaterTerm {}
978 | LGreaterEqualTerm {}
979 | LLessTerm {}
980 | LLessEqualTerm {}
981 | LNotTerm {}
982 | LNotEqualTerm {}
983 | LoadTableTerm {}
984 | LOrTerm {}
985 | MatchTerm {}
986 | ModTerm {}
987 | MultiplyTerm {}
988 | NAndTerm {}
989 | NOrTerm {}
990 | NotTerm {}
991 | OrTerm {}
992 | ShiftLeftTerm {}
993 | ShiftRightTerm {}
994 | SubtractTerm {}
995 | ToBCDTerm {}
996 | ToIntegerTerm {}
997 | XOrTerm {}
998 ;
999
1000 Type2StringOpcode /* "Type4" Opcodes */
1001 : ToDecimalStringTerm {}
1002 | ToHexStringTerm {}
1003 | ToStringTerm {}
1004 ;
1005
1006 Type2BufferOpcode /* "Type5" Opcodes */
1007 : ToBufferTerm {}
1008 | ConcatResTerm {}
1009 ;
1010
1011 Type2BufferOrStringOpcode
1012 : ConcatTerm {}
1013 | MidTerm {}
1014 ;
1015
1016 /*
1017 * A type 3 opcode evaluates to an Integer and cannot have a destination operand
1018 */
1019
1020 Type3Opcode
1021 : EISAIDTerm {}
1022 ;
1023
1024 /* Obsolete
1025 Type4Opcode
1026 : ConcatTerm {}
1027 | ToDecimalStringTerm {}
1028 | ToHexStringTerm {}
1029 | MidTerm {}
1030 | ToStringTerm {}
1031 ;
1032 */
1033
1034
1035 Type5Opcode
1036 : ResourceTemplateTerm {}
1037 | UnicodeTerm {}
1038 | ToUUIDTerm {}
1039 ;
1040
1041 Type6Opcode
1042 : RefOfTerm {}
1043 | DerefOfTerm {}
1044 | IndexTerm {}
1045 | UserTerm {}
1046 ;
1047
1048 IncludeTerm
1049 : PARSEOP_INCLUDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCLUDE);}
1050 String ')' {TrLinkChildren ($<n>3,1,$4);FlOpenIncludeFile ($4);}
1051 TermList
1052 IncludeEndTerm {$$ = TrLinkPeerNodes (3,$<n>3,$7,$8);}
1053 ;
1054
1055 IncludeEndTerm
1056 : PARSEOP_INCLUDE_END {$$ = TrCreateLeafNode (PARSEOP_INCLUDE_END);}
1057 ;
1058
1059 IncludeCStyleTerm
1060 : PARSEOP_INCLUDE_CSTYLE
1061 String {FlOpenIncludeFile ($2);}
1062 ;
1063
1064 LineTerm
1065 : PARSEOP_LINE_CSTYLE
1066 Integer {FlSetLineNumber ($2);}
1067 ;
1068
1069 ExternalTerm
1070 : PARSEOP_EXTERNAL '('
1071 NameString
1072 OptionalObjectTypeKeyword
1073 OptionalParameterTypePackage
1074 OptionalParameterTypesPackage
1075 ')' {$$ = TrCreateNode (PARSEOP_EXTERNAL,4,$3,$4,$5,$6);}
1076 | PARSEOP_EXTERNAL '('
1077 error ')' {$$ = AslDoError(); yyclearin;}
1078 ;
1079
1080
1081 /******* Named Objects *******************************************************/
1082
1083
1084 BankFieldTerm
1085 : PARSEOP_BANKFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BANKFIELD);}
1086 NameString
1087 NameStringItem
1088 TermArgItem
1089 ',' AccessTypeKeyword
1090 ',' LockRuleKeyword
1091 ',' UpdateRuleKeyword
1092 ')' '{'
1093 FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,7,$4,$5,$6,$8,$10,$12,$15);}
1094 | PARSEOP_BANKFIELD '('
1095 error ')' '{' error '}' {$$ = AslDoError(); yyclearin;}
1096 ;
1097
1098 FieldUnitList
1099 : {$$ = NULL;}
1100 | FieldUnit
1101 | FieldUnitList ',' /* Allows a trailing comma at list end */
1102 | FieldUnitList ','
1103 FieldUnit {$$ = TrLinkPeerNode ($1,$3);}
1104 ;
1105
1106 FieldUnit
1107 : FieldUnitEntry {}
1108 | OffsetTerm {}
1109 | AccessAsTerm {}
1110 ;
1111
1112 FieldUnitEntry
1113 : ',' AmlPackageLengthTerm {$$ = TrCreateNode (PARSEOP_RESERVED_BYTES,1,$2);}
1114 | NameSeg ','
1115 AmlPackageLengthTerm {$$ = TrLinkChildNode ($1,$3);}
1116 ;
1117
1118 OffsetTerm
1119 : PARSEOP_OFFSET '('
1120 AmlPackageLengthTerm
1121 ')' {$$ = TrCreateNode (PARSEOP_OFFSET,1,$3);}
1122 | PARSEOP_OFFSET '('
1123 error ')' {$$ = AslDoError(); yyclearin;}
1124 ;
1125
1126 AccessAsTerm
1127 : PARSEOP_ACCESSAS '('
1128 AccessTypeKeyword
1129 OptionalAccessAttribTerm
1130 ')' {$$ = TrCreateNode (PARSEOP_ACCESSAS,2,$3,$4);}
1131 | PARSEOP_ACCESSAS '('
1132 error ')' {$$ = AslDoError(); yyclearin;}
1133 ;
1134
1135 CreateBitFieldTerm
1136 : PARSEOP_CREATEBITFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);}
1137 TermArg
1138 TermArgItem
1139 NameStringItem
1140 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
1141 | PARSEOP_CREATEBITFIELD '('
1142 error ')' {$$ = AslDoError(); yyclearin;}
1143 ;
1144
1145 CreateByteFieldTerm
1146 : PARSEOP_CREATEBYTEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);}
1147 TermArg
1148 TermArgItem
1149 NameStringItem
1150 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
1151 | PARSEOP_CREATEBYTEFIELD '('
1152 error ')' {$$ = AslDoError(); yyclearin;}
1153 ;
1154
1155 CreateDWordFieldTerm
1156 : PARSEOP_CREATEDWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);}
1157 TermArg
1158 TermArgItem
1159 NameStringItem
1160 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
1161 | PARSEOP_CREATEDWORDFIELD '('
1162 error ')' {$$ = AslDoError(); yyclearin;}
1163 ;
1164
1165 CreateFieldTerm
1166 : PARSEOP_CREATEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);}
1167 TermArg
1168 TermArgItem
1169 TermArgItem
1170 NameStringItem
1171 ')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,TrSetNodeFlags ($7, NODE_IS_NAME_DECLARATION));}
1172 | PARSEOP_CREATEFIELD '('
1173 error ')' {$$ = AslDoError(); yyclearin;}
1174 ;
1175
1176 CreateQWordFieldTerm
1177 : PARSEOP_CREATEQWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);}
1178 TermArg
1179 TermArgItem
1180 NameStringItem
1181 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
1182 | PARSEOP_CREATEQWORDFIELD '('
1183 error ')' {$$ = AslDoError(); yyclearin;}
1184 ;
1185
1186 CreateWordFieldTerm
1187 : PARSEOP_CREATEWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);}
1188 TermArg
1189 TermArgItem
1190 NameStringItem
1191 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,TrSetNodeFlags ($6, NODE_IS_NAME_DECLARATION));}
1192 | PARSEOP_CREATEWORDFIELD '('
1193 error ')' {$$ = AslDoError(); yyclearin;}
1194 ;
1195
1196 DataRegionTerm
1197 : PARSEOP_DATATABLEREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);}
1198 NameString
1199 TermArgItem
1200 TermArgItem
1201 TermArgItem
1202 ')' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$6,$7);}
1203 | PARSEOP_DATATABLEREGION '('
1204 error ')' {$$ = AslDoError(); yyclearin;}
1205 ;
1206
1207 DeviceTerm
1208 : PARSEOP_DEVICE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEVICE);}
1209 NameString
1210 ')' '{'
1211 ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
1212 | PARSEOP_DEVICE '('
1213 error ')' {$$ = AslDoError(); yyclearin;}
1214 ;
1215
1216 EventTerm
1217 : PARSEOP_EVENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EVENT);}
1218 NameString
1219 ')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));}
1220 | PARSEOP_EVENT '('
1221 error ')' {$$ = AslDoError(); yyclearin;}
1222 ;
1223
1224 FieldTerm
1225 : PARSEOP_FIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIELD);}
1226 NameString
1227 ',' AccessTypeKeyword
1228 ',' LockRuleKeyword
1229 ',' UpdateRuleKeyword
1230 ')' '{'
1231 FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$6,$8,$10,$13);}
1232 | PARSEOP_FIELD '('
1233 error ')' '{' error '}' {$$ = AslDoError(); yyclearin;}
1234 ;
1235
1236 FunctionTerm
1237 : PARSEOP_FUNCTION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
1238 NameString
1239 OptionalParameterTypePackage
1240 OptionalParameterTypesPackage
1241 ')' '{'
1242 TermList '}' {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),
1243 TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),
1244 TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL),
1245 TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0),$5,$6,$9);}
1246 | PARSEOP_FUNCTION '('
1247 error ')' {$$ = AslDoError(); yyclearin;}
1248 ;
1249
1250 IndexFieldTerm
1251 : PARSEOP_INDEXFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);}
1252 NameString
1253 NameStringItem
1254 ',' AccessTypeKeyword
1255 ',' LockRuleKeyword
1256 ',' UpdateRuleKeyword
1257 ')' '{'
1258 FieldUnitList '}' {$$ = TrLinkChildren ($<n>3,6,$4,$5,$7,$9,$11,$14);}
1259 | PARSEOP_INDEXFIELD '('
1260 error ')' '{' error '}' {$$ = AslDoError(); yyclearin;}
1261 ;
1262
1263 MethodTerm
1264 : PARSEOP_METHOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
1265 NameString
1266 OptionalByteConstExpr {UtCheckIntegerRange ($5, 0, 7);}
1267 OptionalSerializeRuleKeyword
1268 OptionalByteConstExpr
1269 OptionalParameterTypePackage
1270 OptionalParameterTypesPackage
1271 ')' '{'
1272 TermList '}' {$$ = TrLinkChildren ($<n>3,7,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$5,$7,$8,$9,$10,$13);}
1273 | PARSEOP_METHOD '('
1274 error ')' {$$ = AslDoError(); yyclearin;}
1275 ;
1276
1277 MutexTerm
1278 : PARSEOP_MUTEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MUTEX);}
1279 NameString
1280 ',' ByteConstExpr
1281 ')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
1282 | PARSEOP_MUTEX '('
1283 error ')' {$$ = AslDoError(); yyclearin;}
1284 ;
1285
1286 OpRegionTerm
1287 : PARSEOP_OPERATIONREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);}
1288 NameString
1289 ',' OpRegionSpaceIdTerm
1290 TermArgItem
1291 TermArgItem
1292 ')' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8);}
1293 | PARSEOP_OPERATIONREGION '('
1294 error ')' {$$ = AslDoError(); yyclearin;}
1295 ;
1296
1297 OpRegionSpaceIdTerm
1298 : RegionSpaceKeyword {}
1299 | ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
1300 ;
1301
1302 PowerResTerm
1303 : PARSEOP_POWERRESOURCE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);}
1304 NameString
1305 ',' ByteConstExpr
1306 ',' WordConstExpr
1307 ')' '{'
1308 ObjectList '}' {$$ = TrLinkChildren ($<n>3,4,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$8,$11);}
1309 | PARSEOP_POWERRESOURCE '('
1310 error ')' {$$ = AslDoError(); yyclearin;}
1311 ;
1312
1313 ProcessorTerm
1314 : PARSEOP_PROCESSOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_PROCESSOR);}
1315 NameString
1316 ',' ByteConstExpr
1317 OptionalDWordConstExpr
1318 OptionalByteConstExpr
1319 ')' '{'
1320 ObjectList '}' {$$ = TrLinkChildren ($<n>3,5,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6,$7,$8,$11);}
1321 | PARSEOP_PROCESSOR '('
1322 error ')' {$$ = AslDoError(); yyclearin;}
1323 ;
1324
1325 ThermalZoneTerm
1326 : PARSEOP_THERMALZONE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_THERMALZONE);}
1327 NameString
1328 ')' '{'
1329 ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
1330 | PARSEOP_THERMALZONE '('
1331 error ')' {$$ = AslDoError(); yyclearin;}
1332 ;
1333
1334
1335 /******* Namespace modifiers *************************************************/
1336
1337
1338 AliasTerm
1339 : PARSEOP_ALIAS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ALIAS);}
1340 NameString
1341 NameStringItem
1342 ')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));}
1343 | PARSEOP_ALIAS '('
1344 error ')' {$$ = AslDoError(); yyclearin;}
1345 ;
1346
1347 NameTerm
1348 : PARSEOP_NAME '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAME);}
1349 NameString
1350 ',' DataObject
1351 ')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
1352 | PARSEOP_NAME '('
1353 error ')' {$$ = AslDoError(); yyclearin;}
1354 ;
1355
1356 ScopeTerm
1357 : PARSEOP_SCOPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SCOPE);}
1358 NameString
1359 ')' '{'
1360 ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
1361 | PARSEOP_SCOPE '('
1362 error ')' {$$ = AslDoError(); yyclearin;}
1363 ;
1364
1365
1366 /******* Type 1 opcodes *******************************************************/
1367
1368
1369 BreakTerm
1370 : PARSEOP_BREAK {$$ = TrCreateNode (PARSEOP_BREAK, 0);}
1371 ;
1372
1373 BreakPointTerm
1374 : PARSEOP_BREAKPOINT {$$ = TrCreateNode (PARSEOP_BREAKPOINT, 0);}
1375 ;
1376
1377 ContinueTerm
1378 : PARSEOP_CONTINUE {$$ = TrCreateNode (PARSEOP_CONTINUE, 0);}
1379 ;
1380
1381 FatalTerm
1382 : PARSEOP_FATAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FATAL);}
1383 ByteConstExpr
1384 ',' DWordConstExpr
1385 TermArgItem
1386 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
1387 | PARSEOP_FATAL '('
1388 error ')' {$$ = AslDoError(); yyclearin;}
1389 ;
1390
1391 IfElseTerm
1392 : IfTerm ElseTerm {$$ = TrLinkPeerNode ($1,$2);}
1393 ;
1394
1395 IfTerm
1396 : PARSEOP_IF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
1397 TermArg
1398 ')' '{'
1399 TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1400
1401 | PARSEOP_IF '('
1402 error ')' {$$ = AslDoError(); yyclearin;}
1403 ;
1404
1405 ElseTerm
1406 : {$$ = NULL;}
1407 | PARSEOP_ELSE '{' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
1408 TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);}
1409
1410 | PARSEOP_ELSE '{'
1411 error '}' {$$ = AslDoError(); yyclearin;}
1412
1413 | PARSEOP_ELSE
1414 error {$$ = AslDoError(); yyclearin;}
1415
1416 | PARSEOP_ELSEIF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
1417 TermArg {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
1418 ')' '{'
1419 TermList '}' {TrLinkChildren ($<n>5,2,$4,$8);}
1420 ElseTerm {TrLinkPeerNode ($<n>5,$11);}
1421 {$$ = TrLinkChildren ($<n>3,1,$<n>5);}
1422
1423 | PARSEOP_ELSEIF '('
1424 error ')' {$$ = AslDoError(); yyclearin;}
1425
1426 | PARSEOP_ELSEIF
1427 error {$$ = AslDoError(); yyclearin;}
1428 ;
1429
1430 LoadTerm
1431 : PARSEOP_LOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOAD);}
1432 NameString
1433 RequiredTarget
1434 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1435 | PARSEOP_LOAD '('
1436 error ')' {$$ = AslDoError(); yyclearin;}
1437 ;
1438
1439 NoOpTerm
1440 : PARSEOP_NOOP {$$ = TrCreateNode (PARSEOP_NOOP, 0);}
1441 ;
1442
1443 NotifyTerm
1444 : PARSEOP_NOTIFY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOTIFY);}
1445 SuperName
1446 TermArgItem
1447 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1448 | PARSEOP_NOTIFY '('
1449 error ')' {$$ = AslDoError(); yyclearin;}
1450 ;
1451
1452 ReleaseTerm
1453 : PARSEOP_RELEASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RELEASE);}
1454 SuperName
1455 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1456 | PARSEOP_RELEASE '('
1457 error ')' {$$ = AslDoError(); yyclearin;}
1458 ;
1459
1460 ResetTerm
1461 : PARSEOP_RESET '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RESET);}
1462 SuperName
1463 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1464 | PARSEOP_RESET '('
1465 error ')' {$$ = AslDoError(); yyclearin;}
1466 ;
1467
1468 ReturnTerm
1469 : PARSEOP_RETURN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RETURN);}
1470 OptionalReturnArg
1471 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1472 | PARSEOP_RETURN {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_RETURN),1,TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN));}
1473 | PARSEOP_RETURN '('
1474 error ')' {$$ = AslDoError(); yyclearin;}
1475 ;
1476
1477 SignalTerm
1478 : PARSEOP_SIGNAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIGNAL);}
1479 SuperName
1480 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1481 | PARSEOP_SIGNAL '('
1482 error ')' {$$ = AslDoError(); yyclearin;}
1483 ;
1484
1485 SleepTerm
1486 : PARSEOP_SLEEP '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SLEEP);}
1487 TermArg
1488 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1489 | PARSEOP_SLEEP '('
1490 error ')' {$$ = AslDoError(); yyclearin;}
1491 ;
1492
1493 StallTerm
1494 : PARSEOP_STALL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STALL);}
1495 TermArg
1496 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1497 | PARSEOP_STALL '('
1498 error ')' {$$ = AslDoError(); yyclearin;}
1499 ;
1500
1501 SwitchTerm
1502 : PARSEOP_SWITCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SWITCH);}
1503 TermArg
1504 ')' '{'
1505 CaseDefaultTermList '}'
1506 {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1507 | PARSEOP_SWITCH '('
1508 error ')' {$$ = AslDoError(); yyclearin;}
1509 ;
1510
1511 /*
1512 * Case-Default list; allow only one Default term and unlimited Case terms
1513 */
1514
1515 CaseDefaultTermList
1516 : {$$ = NULL;}
1517 | CaseTerm {}
1518 | DefaultTerm {}
1519 | CaseDefaultTermList
1520 CaseTerm {$$ = TrLinkPeerNode ($1,$2);}
1521 | CaseDefaultTermList
1522 DefaultTerm {$$ = TrLinkPeerNode ($1,$2);}
1523
1524 /* Original - attempts to force zero or one default term within the switch */
1525
1526 /*
1527 CaseDefaultTermList
1528 : {$$ = NULL;}
1529 | CaseTermList
1530 DefaultTerm
1531 CaseTermList {$$ = TrLinkPeerNode ($1,TrLinkPeerNode ($2, $3));}
1532 | CaseTermList
1533 CaseTerm {$$ = TrLinkPeerNode ($1,$2);}
1534 ;
1535
1536 CaseTermList
1537 : {$$ = NULL;}
1538 | CaseTerm {}
1539 | CaseTermList
1540 CaseTerm {$$ = TrLinkPeerNode ($1,$2);}
1541 ;
1542 */
1543
1544 CaseTerm
1545 : PARSEOP_CASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CASE);}
1546 DataObject
1547 ')' '{'
1548 TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1549 | PARSEOP_CASE '('
1550 error ')' {$$ = AslDoError(); yyclearin;}
1551 ;
1552
1553 DefaultTerm
1554 : PARSEOP_DEFAULT '{' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFAULT);}
1555 TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);}
1556 | PARSEOP_DEFAULT '{'
1557 error '}' {$$ = AslDoError(); yyclearin;}
1558 ;
1559
1560 UnloadTerm
1561 : PARSEOP_UNLOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNLOAD);}
1562 SuperName
1563 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1564 | PARSEOP_UNLOAD '('
1565 error ')' {$$ = AslDoError(); yyclearin;}
1566 ;
1567
1568 WhileTerm
1569 : PARSEOP_WHILE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WHILE);}
1570 TermArg
1571 ')' '{' TermList '}'
1572 {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
1573 | PARSEOP_WHILE '('
1574 error ')' {$$ = AslDoError(); yyclearin;}
1575 ;
1576
1577
1578 /******* Type 2 opcodes *******************************************************/
1579
1580 AcquireTerm
1581 : PARSEOP_ACQUIRE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACQUIRE);}
1582 SuperName
1583 ',' WordConstExpr
1584 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$6);}
1585 | PARSEOP_ACQUIRE '('
1586 error ')' {$$ = AslDoError(); yyclearin;}
1587 ;
1588
1589 AddTerm
1590 : PARSEOP_ADD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);}
1591 TermArg
1592 TermArgItem
1593 Target
1594 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1595 | PARSEOP_ADD '('
1596 error ')' {$$ = AslDoError(); yyclearin;}
1597 ;
1598
1599 AndTerm
1600 : PARSEOP_AND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_AND);}
1601 TermArg
1602 TermArgItem
1603 Target
1604 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1605 | PARSEOP_AND '('
1606 error ')' {$$ = AslDoError(); yyclearin;}
1607 ;
1608
1609 ConcatTerm
1610 : PARSEOP_CONCATENATE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATE);}
1611 TermArg
1612 TermArgItem
1613 Target
1614 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1615 | PARSEOP_CONCATENATE '('
1616 error ')' {$$ = AslDoError(); yyclearin;}
1617 ;
1618
1619 ConcatResTerm
1620 : PARSEOP_CONCATENATERESTEMPLATE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATERESTEMPLATE);}
1621 TermArg
1622 TermArgItem
1623 Target
1624 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1625 | PARSEOP_CONCATENATERESTEMPLATE '('
1626 error ')' {$$ = AslDoError(); yyclearin;}
1627 ;
1628
1629 CondRefOfTerm
1630 : PARSEOP_CONDREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONDREFOF);}
1631 SuperName
1632 Target
1633 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1634 | PARSEOP_CONDREFOF '('
1635 error ')' {$$ = AslDoError(); yyclearin;}
1636 ;
1637
1638 CopyObjectTerm
1639 : PARSEOP_COPYOBJECT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);}
1640 TermArg
1641 ',' SimpleTarget
1642 ')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
1643 | PARSEOP_COPYOBJECT '('
1644 error ')' {$$ = AslDoError(); yyclearin;}
1645 ;
1646
1647 DecTerm
1648 : PARSEOP_DECREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DECREMENT);}
1649 SuperName
1650 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1651 | PARSEOP_DECREMENT '('
1652 error ')' {$$ = AslDoError(); yyclearin;}
1653 ;
1654
1655 DerefOfTerm
1656 : PARSEOP_DEREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEREFOF);}
1657 TermArg
1658 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1659 | PARSEOP_DEREFOF '('
1660 error ')' {$$ = AslDoError(); yyclearin;}
1661 ;
1662
1663 DivideTerm
1664 : PARSEOP_DIVIDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DIVIDE);}
1665 TermArg
1666 TermArgItem
1667 Target
1668 Target
1669 ')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);}
1670 | PARSEOP_DIVIDE '('
1671 error ')' {$$ = AslDoError(); yyclearin;}
1672 ;
1673
1674 FindSetLeftBitTerm
1675 : PARSEOP_FINDSETLEFTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);}
1676 TermArg
1677 Target
1678 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1679 | PARSEOP_FINDSETLEFTBIT '('
1680 error ')' {$$ = AslDoError(); yyclearin;}
1681 ;
1682
1683 FindSetRightBitTerm
1684 : PARSEOP_FINDSETRIGHTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);}
1685 TermArg
1686 Target
1687 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1688 | PARSEOP_FINDSETRIGHTBIT '('
1689 error ')' {$$ = AslDoError(); yyclearin;}
1690 ;
1691
1692 FromBCDTerm
1693 : PARSEOP_FROMBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FROMBCD);}
1694 TermArg
1695 Target
1696 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1697 | PARSEOP_FROMBCD '('
1698 error ')' {$$ = AslDoError(); yyclearin;}
1699 ;
1700
1701 IncTerm
1702 : PARSEOP_INCREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCREMENT);}
1703 SuperName
1704 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1705 | PARSEOP_INCREMENT '('
1706 error ')' {$$ = AslDoError(); yyclearin;}
1707 ;
1708
1709 IndexTerm
1710 : PARSEOP_INDEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEX);}
1711 TermArg
1712 TermArgItem
1713 Target
1714 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1715 | PARSEOP_INDEX '('
1716 error ')' {$$ = AslDoError(); yyclearin;}
1717 ;
1718
1719 LAndTerm
1720 : PARSEOP_LAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LAND);}
1721 TermArg
1722 TermArgItem
1723 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1724 | PARSEOP_LAND '('
1725 error ')' {$$ = AslDoError(); yyclearin;}
1726 ;
1727
1728 LEqualTerm
1729 : PARSEOP_LEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
1730 TermArg
1731 TermArgItem
1732 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1733 | PARSEOP_LEQUAL '('
1734 error ')' {$$ = AslDoError(); yyclearin;}
1735 ;
1736
1737 LGreaterTerm
1738 : PARSEOP_LGREATER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
1739 TermArg
1740 TermArgItem
1741 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1742 | PARSEOP_LGREATER '('
1743 error ')' {$$ = AslDoError(); yyclearin;}
1744 ;
1745
1746 LGreaterEqualTerm
1747 : PARSEOP_LGREATEREQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
1748 TermArg
1749 TermArgItem
1750 ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1751 | PARSEOP_LGREATEREQUAL '('
1752 error ')' {$$ = AslDoError(); yyclearin;}
1753 ;
1754
1755 LLessTerm
1756 : PARSEOP_LLESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
1757 TermArg
1758 TermArgItem
1759 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1760 | PARSEOP_LLESS '('
1761 error ')' {$$ = AslDoError(); yyclearin;}
1762 ;
1763
1764 LLessEqualTerm
1765 : PARSEOP_LLESSEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
1766 TermArg
1767 TermArgItem
1768 ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1769 | PARSEOP_LLESSEQUAL '('
1770 error ')' {$$ = AslDoError(); yyclearin;}
1771 ;
1772
1773 LNotTerm
1774 : PARSEOP_LNOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LNOT);}
1775 TermArg
1776 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1777 | PARSEOP_LNOT '('
1778 error ')' {$$ = AslDoError(); yyclearin;}
1779 ;
1780
1781 LNotEqualTerm
1782 : PARSEOP_LNOTEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
1783 TermArg
1784 TermArgItem
1785 ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
1786 | PARSEOP_LNOTEQUAL '('
1787 error ')' {$$ = AslDoError(); yyclearin;}
1788 ;
1789
1790 LoadTableTerm
1791 : PARSEOP_LOADTABLE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOADTABLE);}
1792 TermArg
1793 TermArgItem
1794 TermArgItem
1795 OptionalListString
1796 OptionalListString
1797 OptionalReference
1798 ')' {$$ = TrLinkChildren ($<n>3,6,$4,$5,$6,$7,$8,$9);}
1799 | PARSEOP_LOADTABLE '('
1800 error ')' {$$ = AslDoError(); yyclearin;}
1801 ;
1802
1803 LOrTerm
1804 : PARSEOP_LOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOR);}
1805 TermArg
1806 TermArgItem
1807 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1808 | PARSEOP_LOR '('
1809 error ')' {$$ = AslDoError(); yyclearin;}
1810 ;
1811
1812 MatchTerm
1813 : PARSEOP_MATCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MATCH);}
1814 TermArg
1815 ',' MatchOpKeyword
1816 TermArgItem
1817 ',' MatchOpKeyword
1818 TermArgItem
1819 TermArgItem
1820 ')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$7,$9,$10,$11);}
1821 | PARSEOP_MATCH '('
1822 error ')' {$$ = AslDoError(); yyclearin;}
1823 ;
1824
1825 MidTerm
1826 : PARSEOP_MID '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MID);}
1827 TermArg
1828 TermArgItem
1829 TermArgItem
1830 Target
1831 ')' {$$ = TrLinkChildren ($<n>3,4,$4,$5,$6,$7);}
1832 | PARSEOP_MID '('
1833 error ')' {$$ = AslDoError(); yyclearin;}
1834 ;
1835
1836 ModTerm
1837 : PARSEOP_MOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MOD);}
1838 TermArg
1839 TermArgItem
1840 Target
1841 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1842 | PARSEOP_MOD '('
1843 error ')' {$$ = AslDoError(); yyclearin;}
1844 ;
1845
1846 MultiplyTerm
1847 : PARSEOP_MULTIPLY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MULTIPLY);}
1848 TermArg
1849 TermArgItem
1850 Target
1851 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1852 | PARSEOP_MULTIPLY '('
1853 error ')' {$$ = AslDoError(); yyclearin;}
1854 ;
1855
1856 NAndTerm
1857 : PARSEOP_NAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAND);}
1858 TermArg
1859 TermArgItem
1860 Target
1861 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1862 | PARSEOP_NAND '('
1863 error ')' {$$ = AslDoError(); yyclearin;}
1864 ;
1865
1866 NOrTerm
1867 : PARSEOP_NOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOR);}
1868 TermArg
1869 TermArgItem
1870 Target
1871 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1872 | PARSEOP_NOR '('
1873 error ')' {$$ = AslDoError(); yyclearin;}
1874 ;
1875
1876 NotTerm
1877 : PARSEOP_NOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOT);}
1878 TermArg
1879 Target
1880 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1881 | PARSEOP_NOT '('
1882 error ')' {$$ = AslDoError(); yyclearin;}
1883 ;
1884
1885 ObjectTypeTerm
1886 : PARSEOP_OBJECTTYPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);}
1887 SuperName
1888 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1889 | PARSEOP_OBJECTTYPE '('
1890 error ')' {$$ = AslDoError(); yyclearin;}
1891 ;
1892
1893 OrTerm
1894 : PARSEOP_OR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OR);}
1895 TermArg
1896 TermArgItem
1897 Target
1898 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1899 | PARSEOP_OR '('
1900 error ')' {$$ = AslDoError(); yyclearin;}
1901 ;
1902
1903 /*
1904 * In RefOf, the node isn't really a target, but we can't keep track of it after
1905 * we've taken a pointer to it. (hard to tell if a local becomes initialized this way.)
1906 */
1907 RefOfTerm
1908 : PARSEOP_REFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_REFOF);}
1909 SuperName
1910 ')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));}
1911 | PARSEOP_REFOF '('
1912 error ')' {$$ = AslDoError(); yyclearin;}
1913 ;
1914
1915 ShiftLeftTerm
1916 : PARSEOP_SHIFTLEFT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);}
1917 TermArg
1918 TermArgItem
1919 Target
1920 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1921 | PARSEOP_SHIFTLEFT '('
1922 error ')' {$$ = AslDoError(); yyclearin;}
1923 ;
1924
1925 ShiftRightTerm
1926 : PARSEOP_SHIFTRIGHT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);}
1927 TermArg
1928 TermArgItem
1929 Target
1930 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1931 | PARSEOP_SHIFTRIGHT '('
1932 error ')' {$$ = AslDoError(); yyclearin;}
1933 ;
1934
1935 SizeOfTerm
1936 : PARSEOP_SIZEOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIZEOF);}
1937 SuperName
1938 ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
1939 | PARSEOP_SIZEOF '('
1940 error ')' {$$ = AslDoError(); yyclearin;}
1941 ;
1942
1943 StoreTerm
1944 : PARSEOP_STORE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STORE);}
1945 TermArg
1946 ',' SuperName
1947 ')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
1948 | PARSEOP_STORE '('
1949 error ')' {$$ = AslDoError(); yyclearin;}
1950 ;
1951
1952 SubtractTerm
1953 : PARSEOP_SUBTRACT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SUBTRACT);}
1954 TermArg
1955 TermArgItem
1956 Target
1957 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
1958 | PARSEOP_SUBTRACT '('
1959 error ')' {$$ = AslDoError(); yyclearin;}
1960 ;
1961
1962 TimerTerm
1963 : PARSEOP_TIMER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TIMER);}
1964 ')' {$$ = TrLinkChildren ($<n>3,0);}
1965 | PARSEOP_TIMER {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_TIMER),0);}
1966 | PARSEOP_TIMER '('
1967 error ')' {$$ = AslDoError(); yyclearin;}
1968 ;
1969
1970 ToBCDTerm
1971 : PARSEOP_TOBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBCD);}
1972 TermArg
1973 Target
1974 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1975 | PARSEOP_TOBCD '('
1976 error ')' {$$ = AslDoError(); yyclearin;}
1977 ;
1978
1979 ToBufferTerm
1980 : PARSEOP_TOBUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBUFFER);}
1981 TermArg
1982 Target
1983 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1984 | PARSEOP_TOBUFFER '('
1985 error ')' {$$ = AslDoError(); yyclearin;}
1986 ;
1987
1988 ToDecimalStringTerm
1989 : PARSEOP_TODECIMALSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);}
1990 TermArg
1991 Target
1992 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
1993 | PARSEOP_TODECIMALSTRING '('
1994 error ')' {$$ = AslDoError(); yyclearin;}
1995 ;
1996
1997 ToHexStringTerm
1998 : PARSEOP_TOHEXSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);}
1999 TermArg
2000 Target
2001 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
2002 | PARSEOP_TOHEXSTRING '('
2003 error ')' {$$ = AslDoError(); yyclearin;}
2004 ;
2005
2006 ToIntegerTerm
2007 : PARSEOP_TOINTEGER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOINTEGER);}
2008 TermArg
2009 Target
2010 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
2011 | PARSEOP_TOINTEGER '('
2012 error ')' {$$ = AslDoError(); yyclearin;}
2013 ;
2014
2015 ToStringTerm
2016 : PARSEOP_TOSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOSTRING);}
2017 TermArg
2018 OptionalCount
2019 Target
2020 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
2021 | PARSEOP_TOSTRING '('
2022 error ')' {$$ = AslDoError(); yyclearin;}
2023 ;
2024
2025 ToUUIDTerm
2026 : PARSEOP_TOUUID '('
2027 StringData ')' {$$ = TrUpdateNode (PARSEOP_TOUUID, $3);}
2028 | PARSEOP_TOUUID '('
2029 error ')' {$$ = AslDoError(); yyclearin;}
2030 ;
2031
2032 WaitTerm
2033 : PARSEOP_WAIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WAIT);}
2034 SuperName
2035 TermArgItem
2036 ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
2037 | PARSEOP_WAIT '('
2038 error ')' {$$ = AslDoError(); yyclearin;}
2039 ;
2040
2041 XOrTerm
2042 : PARSEOP_XOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_XOR);}
2043 TermArg
2044 TermArgItem
2045 Target
2046 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$5,$6);}
2047 | PARSEOP_XOR '('
2048 error ')' {$$ = AslDoError(); yyclearin;}
2049 ;
2050
2051
2052 /******* Keywords *************************************************************/
2053
2054
2055 ObjectTypeKeyword
2056 : PARSEOP_OBJECTTYPE_UNK {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
2057 | PARSEOP_OBJECTTYPE_INT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_INT);}
2058 | PARSEOP_OBJECTTYPE_STR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_STR);}
2059 | PARSEOP_OBJECTTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BUF);}
2060 | PARSEOP_OBJECTTYPE_PKG {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PKG);}
2061 | PARSEOP_OBJECTTYPE_FLD {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_FLD);}
2062 | PARSEOP_OBJECTTYPE_DEV {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DEV);}
2063 | PARSEOP_OBJECTTYPE_EVT {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_EVT);}
2064 | PARSEOP_OBJECTTYPE_MTH {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTH);}
2065 | PARSEOP_OBJECTTYPE_MTX {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_MTX);}
2066 | PARSEOP_OBJECTTYPE_OPR {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_OPR);}
2067 | PARSEOP_OBJECTTYPE_POW {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_POW);}
2068 | PARSEOP_OBJECTTYPE_PRO {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_PRO);}
2069 | PARSEOP_OBJECTTYPE_THZ {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_THZ);}
2070 | PARSEOP_OBJECTTYPE_BFF {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_BFF);}
2071 | PARSEOP_OBJECTTYPE_DDB {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_DDB);}
2072 ;
2073
2074 AccessTypeKeyword
2075 : PARSEOP_ACCESSTYPE_ANY {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_ANY);}
2076 | PARSEOP_ACCESSTYPE_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BYTE);}
2077 | PARSEOP_ACCESSTYPE_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_WORD);}
2078 | PARSEOP_ACCESSTYPE_DWORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_DWORD);}
2079 | PARSEOP_ACCESSTYPE_QWORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_QWORD);}
2080 | PARSEOP_ACCESSTYPE_BUF {$$ = TrCreateLeafNode (PARSEOP_ACCESSTYPE_BUF);}
2081 ;
2082
2083 AccessAttribKeyword
2084 : PARSEOP_ACCESSATTRIB_QUICK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_QUICK );}
2085 | PARSEOP_ACCESSATTRIB_SND_RCV {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_SND_RCV);}
2086 | PARSEOP_ACCESSATTRIB_BYTE {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BYTE);}
2087 | PARSEOP_ACCESSATTRIB_WORD {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD);}
2088 | PARSEOP_ACCESSATTRIB_BLOCK {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK);}
2089 | PARSEOP_ACCESSATTRIB_WORD_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_WORD_CALL);}
2090 | PARSEOP_ACCESSATTRIB_BLOCK_CALL {$$ = TrCreateLeafNode (PARSEOP_ACCESSATTRIB_BLOCK_CALL);}
2091 ;
2092
2093 LockRuleKeyword
2094 : PARSEOP_LOCKRULE_LOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_LOCK);}
2095 | PARSEOP_LOCKRULE_NOLOCK {$$ = TrCreateLeafNode (PARSEOP_LOCKRULE_NOLOCK);}
2096 ;
2097
2098 UpdateRuleKeyword
2099 : PARSEOP_UPDATERULE_PRESERVE {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_PRESERVE);}
2100 | PARSEOP_UPDATERULE_ONES {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ONES);}
2101 | PARSEOP_UPDATERULE_ZEROS {$$ = TrCreateLeafNode (PARSEOP_UPDATERULE_ZEROS);}
2102 ;
2103
2104
2105 RegionSpaceKeyword
2106 : PARSEOP_REGIONSPACE_IO {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IO);}
2107 | PARSEOP_REGIONSPACE_MEM {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_MEM);}
2108 | PARSEOP_REGIONSPACE_PCI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCI);}
2109 | PARSEOP_REGIONSPACE_EC {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_EC);}
2110 | PARSEOP_REGIONSPACE_SMBUS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_SMBUS);}
2111 | PARSEOP_REGIONSPACE_CMOS {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_CMOS);}
2112 | PARSEOP_REGIONSPACE_PCIBAR {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_PCIBAR);}
2113 | PARSEOP_REGIONSPACE_IPMI {$$ = TrCreateLeafNode (PARSEOP_REGIONSPACE_IPMI);}
2114 ;
2115
2116 AddressSpaceKeyword
2117 : ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);}
2118 | RegionSpaceKeyword {}
2119 | PARSEOP_ADDRESSSPACE_FFIXEDHW {$$ = TrCreateLeafNode (PARSEOP_ADDRESSSPACE_FFIXEDHW);}
2120 ;
2121
2122
2123 SerializeRuleKeyword
2124 : PARSEOP_SERIALIZERULE_SERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_SERIAL);}
2125 | PARSEOP_SERIALIZERULE_NOTSERIAL {$$ = TrCreateLeafNode (PARSEOP_SERIALIZERULE_NOTSERIAL);}
2126 ;
2127
2128 MatchOpKeyword
2129 : PARSEOP_MATCHTYPE_MTR {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MTR);}
2130 | PARSEOP_MATCHTYPE_MEQ {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MEQ);}
2131 | PARSEOP_MATCHTYPE_MLE {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLE);}
2132 | PARSEOP_MATCHTYPE_MLT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MLT);}
2133 | PARSEOP_MATCHTYPE_MGE {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGE);}
2134 | PARSEOP_MATCHTYPE_MGT {$$ = TrCreateLeafNode (PARSEOP_MATCHTYPE_MGT);}
2135 ;
2136
2137 DMATypeKeyword
2138 : PARSEOP_DMATYPE_A {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_A);}
2139 | PARSEOP_DMATYPE_COMPATIBILITY {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_COMPATIBILITY);}
2140 | PARSEOP_DMATYPE_B {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_B);}
2141 | PARSEOP_DMATYPE_F {$$ = TrCreateLeafNode (PARSEOP_DMATYPE_F);}
2142 ;
2143
2144 XferTypeKeyword
2145 : PARSEOP_XFERTYPE_8 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8);}
2146 | PARSEOP_XFERTYPE_8_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_8_16);}
2147 | PARSEOP_XFERTYPE_16 {$$ = TrCreateLeafNode (PARSEOP_XFERTYPE_16);}
2148 ;
2149
2150 ResourceTypeKeyword
2151 : PARSEOP_RESOURCETYPE_CONSUMER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_CONSUMER);}
2152 | PARSEOP_RESOURCETYPE_PRODUCER {$$ = TrCreateLeafNode (PARSEOP_RESOURCETYPE_PRODUCER);}
2153 ;
2154
2155 MinKeyword
2156 : PARSEOP_MINTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_FIXED);}
2157 | PARSEOP_MINTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MINTYPE_NOTFIXED);}
2158 ;
2159
2160 MaxKeyword
2161 : PARSEOP_MAXTYPE_FIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_FIXED);}
2162 | PARSEOP_MAXTYPE_NOTFIXED {$$ = TrCreateLeafNode (PARSEOP_MAXTYPE_NOTFIXED);}
2163 ;
2164
2165 DecodeKeyword
2166 : PARSEOP_DECODETYPE_POS {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_POS);}
2167 | PARSEOP_DECODETYPE_SUB {$$ = TrCreateLeafNode (PARSEOP_DECODETYPE_SUB);}
2168 ;
2169
2170 RangeTypeKeyword
2171 : PARSEOP_RANGETYPE_ISAONLY {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ISAONLY);}
2172 | PARSEOP_RANGETYPE_NONISAONLY {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_NONISAONLY);}
2173 | PARSEOP_RANGETYPE_ENTIRE {$$ = TrCreateLeafNode (PARSEOP_RANGETYPE_ENTIRE);}
2174 ;
2175
2176 MemTypeKeyword
2177 : PARSEOP_MEMTYPE_CACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_CACHEABLE);}
2178 | PARSEOP_MEMTYPE_WRITECOMBINING {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_WRITECOMBINING);}
2179 | PARSEOP_MEMTYPE_PREFETCHABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_PREFETCHABLE);}
2180 | PARSEOP_MEMTYPE_NONCACHEABLE {$$ = TrCreateLeafNode (PARSEOP_MEMTYPE_NONCACHEABLE);}
2181 ;
2182
2183 OptionalReadWriteKeyword
2184 : {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
2185 | PARSEOP_READWRITETYPE_BOTH {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_BOTH);}
2186 | PARSEOP_READWRITETYPE_READONLY {$$ = TrCreateLeafNode (PARSEOP_READWRITETYPE_READONLY);}
2187 ;
2188
2189 InterruptTypeKeyword
2190 : PARSEOP_INTTYPE_EDGE {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_EDGE);}
2191 | PARSEOP_INTTYPE_LEVEL {$$ = TrCreateLeafNode (PARSEOP_INTTYPE_LEVEL);}
2192 ;
2193
2194 InterruptLevel
2195 : PARSEOP_INTLEVEL_ACTIVEHIGH {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVEHIGH);}
2196 | PARSEOP_INTLEVEL_ACTIVELOW {$$ = TrCreateLeafNode (PARSEOP_INTLEVEL_ACTIVELOW);}
2197 ;
2198
2199 ShareTypeKeyword
2200 : PARSEOP_SHARETYPE_SHARED {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_SHARED);}
2201 | PARSEOP_SHARETYPE_EXCLUSIVE {$$ = TrCreateLeafNode (PARSEOP_SHARETYPE_EXCLUSIVE);}
2202 ;
2203
2204 IODecodeKeyword
2205 : PARSEOP_IODECODETYPE_16 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_16);}
2206 | PARSEOP_IODECODETYPE_10 {$$ = TrCreateLeafNode (PARSEOP_IODECODETYPE_10);}
2207 ;
2208
2209 TypeKeyword
2210 : PARSEOP_TYPE_TRANSLATION {$$ = TrCreateLeafNode (PARSEOP_TYPE_TRANSLATION);}
2211 | PARSEOP_TYPE_STATIC {$$ = TrCreateLeafNode (PARSEOP_TYPE_STATIC);}
2212 ;
2213
2214 TranslationKeyword
2215 : PARSEOP_TRANSLATIONTYPE_SPARSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_SPARSE);}
2216 | PARSEOP_TRANSLATIONTYPE_DENSE {$$ = TrCreateLeafNode (PARSEOP_TRANSLATIONTYPE_DENSE);}
2217 ;
2218
2219 AddressKeyword
2220 : PARSEOP_ADDRESSTYPE_MEMORY {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_MEMORY);}
2221 | PARSEOP_ADDRESSTYPE_RESERVED {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_RESERVED);}
2222 | PARSEOP_ADDRESSTYPE_NVS {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_NVS);}
2223 | PARSEOP_ADDRESSTYPE_ACPI {$$ = TrCreateLeafNode (PARSEOP_ADDRESSTYPE_ACPI);}
2224 ;
2225
2226
2227 /******* Miscellaneous Types **************************************************/
2228
2229
2230 SuperName
2231 : NameString {}
2232 | ArgTerm {}
2233 | LocalTerm {}
2234 | DebugTerm {}
2235 | Type6Opcode {}
2236 /* | UserTerm {} */ /* Caused reduce/reduce with Type6Opcode->UserTerm */
2237 ;
2238
2239 ArgTerm
2240 : PARSEOP_ARG0 {$$ = TrCreateLeafNode (PARSEOP_ARG0);}
2241 | PARSEOP_ARG1 {$$ = TrCreateLeafNode (PARSEOP_ARG1);}
2242 | PARSEOP_ARG2 {$$ = TrCreateLeafNode (PARSEOP_ARG2);}
2243 | PARSEOP_ARG3 {$$ = TrCreateLeafNode (PARSEOP_ARG3);}
2244 | PARSEOP_ARG4 {$$ = TrCreateLeafNode (PARSEOP_ARG4);}
2245 | PARSEOP_ARG5 {$$ = TrCreateLeafNode (PARSEOP_ARG5);}
2246 | PARSEOP_ARG6 {$$ = TrCreateLeafNode (PARSEOP_ARG6);}
2247 ;
2248
2249 LocalTerm
2250 : PARSEOP_LOCAL0 {$$ = TrCreateLeafNode (PARSEOP_LOCAL0);}
2251 | PARSEOP_LOCAL1 {$$ = TrCreateLeafNode (PARSEOP_LOCAL1);}
2252 | PARSEOP_LOCAL2 {$$ = TrCreateLeafNode (PARSEOP_LOCAL2);}
2253 | PARSEOP_LOCAL3 {$$ = TrCreateLeafNode (PARSEOP_LOCAL3);}
2254 | PARSEOP_LOCAL4 {$$ = TrCreateLeafNode (PARSEOP_LOCAL4);}
2255 | PARSEOP_LOCAL5 {$$ = TrCreateLeafNode (PARSEOP_LOCAL5);}
2256 | PARSEOP_LOCAL6 {$$ = TrCreateLeafNode (PARSEOP_LOCAL6);}
2257 | PARSEOP_LOCAL7 {$$ = TrCreateLeafNode (PARSEOP_LOCAL7);}
2258 ;
2259
2260 DebugTerm
2261 : PARSEOP_DEBUG {$$ = TrCreateLeafNode (PARSEOP_DEBUG);}
2262 ;
2263
2264
2265 ByteConst
2266 : Integer {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
2267 ;
2268
2269 WordConst
2270 : Integer {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
2271 ;
2272
2273 DWordConst
2274 : Integer {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
2275 ;
2276
2277 QWordConst
2278 : Integer {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
2279 ;
2280
2281 Integer
2282 : PARSEOP_INTEGER {$$ = TrCreateValuedLeafNode (PARSEOP_INTEGER, AslCompilerlval.i);}
2283 ;
2284
2285 String
2286 : PARSEOP_STRING_LITERAL {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, (ACPI_NATIVE_INT) AslCompilerlval.s);}
2287 ;
2288
2289 ConstTerm
2290 : ConstExprTerm {}
2291 | PARSEOP_REVISION {$$ = TrCreateLeafNode (PARSEOP_REVISION);}
2292 ;
2293
2294 ByteConstExpr
2295 : Type3Opcode {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
2296 | Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
2297 | ConstExprTerm {$$ = TrUpdateNode (PARSEOP_BYTECONST, $1);}
2298 | ByteConst {}
2299 ;
2300
2301 WordConstExpr
2302 : Type3Opcode {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
2303 | Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
2304 | ConstExprTerm {$$ = TrUpdateNode (PARSEOP_WORDCONST, $1);}
2305 | WordConst {}
2306 ;
2307
2308 DWordConstExpr
2309 : Type3Opcode {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
2310 | Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
2311 | ConstExprTerm {$$ = TrUpdateNode (PARSEOP_DWORDCONST, $1);}
2312 | DWordConst {}
2313 ;
2314
2315 QWordConstExpr
2316 : Type3Opcode {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
2317 | Type2IntegerOpcode {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
2318 | ConstExprTerm {$$ = TrUpdateNode (PARSEOP_QWORDCONST, $1);}
2319 | QWordConst {}
2320 ;
2321
2322 ConstExprTerm
2323 : PARSEOP_ZERO {$$ = TrCreateValuedLeafNode (PARSEOP_ZERO, 0);}
2324 | PARSEOP_ONE {$$ = TrCreateValuedLeafNode (PARSEOP_ONE, 1);}
2325 | PARSEOP_ONES {$$ = TrCreateValuedLeafNode (PARSEOP_ONES, ACPI_UINT64_MAX);}
2326 | PARSEOP___DATE__ {$$ = TrCreateConstantLeafNode (PARSEOP___DATE__);}
2327 | PARSEOP___FILE__ {$$ = TrCreateConstantLeafNode (PARSEOP___FILE__);}
2328 | PARSEOP___LINE__ {$$ = TrCreateConstantLeafNode (PARSEOP___LINE__);}
2329 ;
2330
2331 /* OptionalCount must appear before ByteList or an incorrect reduction will result */
2332
2333 OptionalCount
2334 : {$$ = TrCreateLeafNode (PARSEOP_ONES);} /* Placeholder is a OnesOp object */
2335 | ',' {$$ = TrCreateLeafNode (PARSEOP_ONES);} /* Placeholder is a OnesOp object */
2336 | ',' TermArg {$$ = $2;}
2337 ;
2338
2339
2340 BufferTerm
2341 : PARSEOP_BUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BUFFER);}
2342 OptionalTermArg
2343 ')' '{'
2344 BufferTermData '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
2345 | PARSEOP_BUFFER '('
2346 error ')' {$$ = AslDoError(); yyclearin;}
2347 ;
2348
2349 BufferTermData
2350 : ByteList {}
2351 | StringData {}
2352 ;
2353
2354 ByteList
2355 : {$$ = NULL;}
2356 | ByteConstExpr
2357 | ByteList ',' /* Allows a trailing comma at list end */
2358 | ByteList ','
2359 ByteConstExpr {$$ = TrLinkPeerNode ($1,$3);}
2360 ;
2361
2362 DWordList
2363 : {$$ = NULL;}
2364 | DWordConstExpr
2365 | DWordList ',' /* Allows a trailing comma at list end */
2366 | DWordList ','
2367 DWordConstExpr {$$ = TrLinkPeerNode ($1,$3);}
2368 ;
2369
2370 PackageTerm
2371 : PARSEOP_PACKAGE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VAR_PACKAGE);}
2372 VarPackageLengthTerm
2373 ')' '{'
2374 PackageList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
2375 | PARSEOP_PACKAGE '('
2376 error ')' {$$ = AslDoError(); yyclearin;}
2377 ;
2378
2379 VarPackageLengthTerm
2380 : {$$ = TrCreateLeafNode (PARSEOP_DEFAULT_ARG);}
2381 | TermArg {$$ = $1;}
2382 ;
2383
2384 PackageList
2385 : {$$ = NULL;}
2386 | PackageElement
2387 | PackageList ',' /* Allows a trailing comma at list end */
2388 | PackageList ','
2389 PackageElement {$$ = TrLinkPeerNode ($1,$3);}
2390 ;
2391
2392 PackageElement
2393 : DataObject {}
2394 | NameString {}
2395 ;
2396
2397 EISAIDTerm
2398 : PARSEOP_EISAID '('
2399 StringData ')' {$$ = TrUpdateNode (PARSEOP_EISAID, $3);}
2400 | PARSEOP_EISAID '('
2401 error ')' {$$ = AslDoError(); yyclearin;}
2402 ;
2403
2404
2405 /******* Resources and Memory ***********************************************/
2406
2407
2408 /*
2409 * Note: Create two default nodes to allow conversion to a Buffer AML opcode
2410 * Also, insert the EndTag at the end of the template.
2411 */
2412 ResourceTemplateTerm
2413 : PARSEOP_RESOURCETEMPLATE '(' ')'
2414 '{'
2415 ResourceMacroList '}' {$$ = TrCreateNode (PARSEOP_RESOURCETEMPLATE,4,
2416 TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
2417 TrCreateLeafNode (PARSEOP_DEFAULT_ARG),
2418 $5,
2419 TrCreateLeafNode (PARSEOP_ENDTAG));}
2420 ;
2421
2422 UnicodeTerm
2423 : PARSEOP_UNICODE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNICODE);}
2424 StringData
2425 ')' {$$ = TrLinkChildren ($<n>3,2,0,$4);}
2426 | PARSEOP_UNICODE '('
2427 error ')' {$$ = AslDoError(); yyclearin;}
2428 ;
2429
2430 ResourceMacroList
2431 : {$$ = NULL;}
2432 | ResourceMacroList
2433 ResourceMacroTerm {$$ = TrLinkPeerNode ($1,$2);}
2434 ;
2435
2436 ResourceMacroTerm
2437 : DMATerm {}
2438 | DWordIOTerm {}
2439 | DWordMemoryTerm {}
2440 | DWordSpaceTerm {}
2441 | EndDependentFnTerm {}
2442 | ExtendedIOTerm {}
2443 | ExtendedMemoryTerm {}
2444 | ExtendedSpaceTerm {}
2445 | FixedIOTerm {}
2446 | InterruptTerm {}
2447 | IOTerm {}
2448 | IRQNoFlagsTerm {}
2449 | IRQTerm {}
2450 | Memory24Term {}
2451 | Memory32FixedTerm {}
2452 | Memory32Term {}
2453 | QWordIOTerm {}
2454 | QWordMemoryTerm {}
2455 | QWordSpaceTerm {}
2456 | RegisterTerm {}
2457 | StartDependentFnTerm {}
2458 | StartDependentFnNoPriTerm {}
2459 | VendorLongTerm {}
2460 | VendorShortTerm {}
2461 | WordBusNumberTerm {}
2462 | WordIOTerm {}
2463 | WordSpaceTerm {}
2464 ;
2465
2466 DMATerm
2467 : PARSEOP_DMA '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DMA);}
2468 DMATypeKeyword
2469 OptionalBusMasterKeyword
2470 ',' XferTypeKeyword
2471 OptionalNameString_Last
2472 ')' '{'
2473 ByteList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$5,$7,$8,$11);}
2474 | PARSEOP_DMA '('
2475 error ')' {$$ = AslDoError(); yyclearin;}
2476 ;
2477
2478 DWordIOTerm
2479 : PARSEOP_DWORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDIO);}
2480 OptionalResourceType_First
2481 OptionalMinType
2482 OptionalMaxType
2483 OptionalDecodeType
2484 OptionalRangeType
2485 ',' DWordConstExpr
2486 ',' DWordConstExpr
2487 ',' DWordConstExpr
2488 ',' DWordConstExpr
2489 ',' DWordConstExpr
2490 OptionalByteConstExpr
2491 OptionalStringData
2492 OptionalNameString
2493 OptionalType
2494 OptionalTranslationType_Last
2495 ')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
2496 | PARSEOP_DWORDIO '('
2497 error ')' {$$ = AslDoError(); yyclearin;}
2498 ;
2499
2500 DWordMemoryTerm
2501 : PARSEOP_DWORDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDMEMORY);}
2502 OptionalResourceType_First
2503 OptionalDecodeType
2504 OptionalMinType
2505 OptionalMaxType
2506 OptionalMemType
2507 ',' OptionalReadWriteKeyword
2508 ',' DWordConstExpr
2509 ',' DWordConstExpr
2510 ',' DWordConstExpr
2511 ',' DWordConstExpr
2512 ',' DWordConstExpr
2513 OptionalByteConstExpr
2514 OptionalStringData
2515 OptionalNameString
2516 OptionalAddressRange
2517 OptionalType_Last
2518 ')' {$$ = TrLinkChildren ($<n>3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
2519 | PARSEOP_DWORDMEMORY '('
2520 error ')' {$$ = AslDoError(); yyclearin;}
2521 ;
2522
2523 DWordSpaceTerm
2524 : PARSEOP_DWORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DWORDSPACE);}
2525 ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
2526 OptionalResourceType
2527 OptionalDecodeType
2528 OptionalMinType
2529 OptionalMaxType
2530 ',' ByteConstExpr
2531 ',' DWordConstExpr
2532 ',' DWordConstExpr
2533 ',' DWordConstExpr
2534 ',' DWordConstExpr
2535 ',' DWordConstExpr
2536 OptionalByteConstExpr
2537 OptionalStringData
2538 OptionalNameString_Last
2539 ')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
2540 | PARSEOP_DWORDSPACE '('
2541 error ')' {$$ = AslDoError(); yyclearin;}
2542 ;
2543
2544
2545 EndDependentFnTerm
2546 : PARSEOP_ENDDEPENDENTFN '('
2547 ')' {$$ = TrCreateLeafNode (PARSEOP_ENDDEPENDENTFN);}
2548 | PARSEOP_ENDDEPENDENTFN '('
2549 error ')' {$$ = AslDoError(); yyclearin;}
2550 ;
2551
2552 ExtendedIOTerm
2553 : PARSEOP_EXTENDEDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDIO);}
2554 OptionalResourceType_First
2555 OptionalMinType
2556 OptionalMaxType
2557 OptionalDecodeType
2558 OptionalRangeType
2559 ',' QWordConstExpr
2560 ',' QWordConstExpr
2561 ',' QWordConstExpr
2562 ',' QWordConstExpr
2563 ',' QWordConstExpr
2564 OptionalQWordConstExpr
2565 OptionalNameString
2566 OptionalType
2567 OptionalTranslationType_Last
2568 ')' {$$ = TrLinkChildren ($<n>3,14,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22);}
2569 | PARSEOP_EXTENDEDIO '('
2570 error ')' {$$ = AslDoError(); yyclearin;}
2571 ;
2572
2573 ExtendedMemoryTerm
2574 : PARSEOP_EXTENDEDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDMEMORY);}
2575 OptionalResourceType_First
2576 OptionalDecodeType
2577 OptionalMinType
2578 OptionalMaxType
2579 OptionalMemType
2580 ',' OptionalReadWriteKeyword
2581 ',' QWordConstExpr
2582 ',' QWordConstExpr
2583 ',' QWordConstExpr
2584 ',' QWordConstExpr
2585 ',' QWordConstExpr
2586 OptionalQWordConstExpr
2587 OptionalNameString
2588 OptionalAddressRange
2589 OptionalType_Last
2590 ')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24);}
2591 | PARSEOP_EXTENDEDMEMORY '('
2592 error ')' {$$ = AslDoError(); yyclearin;}
2593 ;
2594
2595 ExtendedSpaceTerm
2596 : PARSEOP_EXTENDEDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EXTENDEDSPACE);}
2597 ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
2598 OptionalResourceType
2599 OptionalDecodeType
2600 OptionalMinType
2601 OptionalMaxType
2602 ',' ByteConstExpr
2603 ',' QWordConstExpr
2604 ',' QWordConstExpr
2605 ',' QWordConstExpr
2606 ',' QWordConstExpr
2607 ',' QWordConstExpr
2608 OptionalQWordConstExpr
2609 OptionalNameString_Last
2610 ')' {$$ = TrLinkChildren ($<n>3,13,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23);}
2611 | PARSEOP_EXTENDEDSPACE '('
2612 error ')' {$$ = AslDoError(); yyclearin;}
2613 ;
2614
2615 FixedIOTerm
2616 : PARSEOP_FIXEDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIXEDIO);}
2617 WordConstExpr
2618 ',' ByteConstExpr
2619 OptionalNameString_Last
2620 ')' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$7);}
2621 | PARSEOP_FIXEDIO '('
2622 error ')' {$$ = AslDoError(); yyclearin;}
2623 ;
2624
2625 InterruptTerm
2626 : PARSEOP_INTERRUPT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INTERRUPT);}
2627 OptionalResourceType_First
2628 ',' InterruptTypeKeyword
2629 ',' InterruptLevel
2630 OptionalShareType
2631 OptionalByteConstExpr
2632 OptionalStringData
2633 OptionalNameString_Last
2634 ')' '{'
2635 DWordList '}' {$$ = TrLinkChildren ($<n>3,8,$4,$6,$8,$9,$10,$11,$12,$15);}
2636 | PARSEOP_INTERRUPT '('
2637 error ')' {$$ = AslDoError(); yyclearin;}
2638 ;
2639
2640 IOTerm
2641 : PARSEOP_IO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IO);}
2642 IODecodeKeyword
2643 ',' WordConstExpr
2644 ',' WordConstExpr
2645 ',' ByteConstExpr
2646 ',' ByteConstExpr
2647 OptionalNameString_Last
2648 ')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
2649 | PARSEOP_IO '('
2650 error ')' {$$ = AslDoError(); yyclearin;}
2651 ;
2652
2653 IRQNoFlagsTerm
2654 : PARSEOP_IRQNOFLAGS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IRQNOFLAGS);}
2655 OptionalNameString_First
2656 ')' '{'
2657 ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
2658 | PARSEOP_IRQNOFLAGS '('
2659 error ')' {$$ = AslDoError(); yyclearin;}
2660 ;
2661
2662 IRQTerm
2663 : PARSEOP_IRQ '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IRQ);}
2664 InterruptTypeKeyword
2665 ',' InterruptLevel
2666 OptionalShareType
2667 OptionalNameString_Last
2668 ')' '{'
2669 ByteList '}' {$$ = TrLinkChildren ($<n>3,5,$4,$6,$7,$8,$11);}
2670 | PARSEOP_IRQ '('
2671 error ')' {$$ = AslDoError(); yyclearin;}
2672 ;
2673
2674 Memory24Term
2675 : PARSEOP_MEMORY24 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY24);}
2676 OptionalReadWriteKeyword
2677 ',' WordConstExpr
2678 ',' WordConstExpr
2679 ',' WordConstExpr
2680 ',' WordConstExpr
2681 OptionalNameString_Last
2682 ')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
2683 | PARSEOP_MEMORY24 '('
2684 error ')' {$$ = AslDoError(); yyclearin;}
2685 ;
2686
2687 Memory32FixedTerm
2688 : PARSEOP_MEMORY32FIXED '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32FIXED);}
2689 OptionalReadWriteKeyword
2690 ',' DWordConstExpr
2691 ',' DWordConstExpr
2692 OptionalNameString_Last
2693 ')' {$$ = TrLinkChildren ($<n>3,4,$4,$6,$8,$9);}
2694 | PARSEOP_MEMORY32FIXED '('
2695 error ')' {$$ = AslDoError(); yyclearin;}
2696 ;
2697
2698 Memory32Term
2699 : PARSEOP_MEMORY32 '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MEMORY32);}
2700 OptionalReadWriteKeyword
2701 ',' DWordConstExpr
2702 ',' DWordConstExpr
2703 ',' DWordConstExpr
2704 ',' DWordConstExpr
2705 OptionalNameString_Last
2706 ')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$12,$13);}
2707 | PARSEOP_MEMORY32 '('
2708 error ')' {$$ = AslDoError(); yyclearin;}
2709 ;
2710
2711 QWordIOTerm
2712 : PARSEOP_QWORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDIO);}
2713 OptionalResourceType_First
2714 OptionalMinType
2715 OptionalMaxType
2716 OptionalDecodeType
2717 OptionalRangeType
2718 ',' QWordConstExpr
2719 ',' QWordConstExpr
2720 ',' QWordConstExpr
2721 ',' QWordConstExpr
2722 ',' QWordConstExpr
2723 OptionalByteConstExpr
2724 OptionalStringData
2725 OptionalNameString
2726 OptionalType
2727 OptionalTranslationType_Last
2728 ')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
2729 | PARSEOP_QWORDIO '('
2730 error ')' {$$ = AslDoError(); yyclearin;}
2731 ;
2732
2733 QWordMemoryTerm
2734 : PARSEOP_QWORDMEMORY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDMEMORY);}
2735 OptionalResourceType_First
2736 OptionalDecodeType
2737 OptionalMinType
2738 OptionalMaxType
2739 OptionalMemType
2740 ',' OptionalReadWriteKeyword
2741 ',' QWordConstExpr
2742 ',' QWordConstExpr
2743 ',' QWordConstExpr
2744 ',' QWordConstExpr
2745 ',' QWordConstExpr
2746 OptionalByteConstExpr
2747 OptionalStringData
2748 OptionalNameString
2749 OptionalAddressRange
2750 OptionalType_Last
2751 ')' {$$ = TrLinkChildren ($<n>3,16,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$20,$21,$22,$23,$24,$25);}
2752 | PARSEOP_QWORDMEMORY '('
2753 error ')' {$$ = AslDoError(); yyclearin;}
2754 ;
2755
2756 QWordSpaceTerm
2757 : PARSEOP_QWORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_QWORDSPACE);}
2758 ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
2759 OptionalResourceType
2760 OptionalDecodeType
2761 OptionalMinType
2762 OptionalMaxType
2763 ',' ByteConstExpr
2764 ',' QWordConstExpr
2765 ',' QWordConstExpr
2766 ',' QWordConstExpr
2767 ',' QWordConstExpr
2768 ',' QWordConstExpr
2769 OptionalByteConstExpr
2770 OptionalStringData
2771 OptionalNameString_Last
2772 ')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
2773 | PARSEOP_QWORDSPACE '('
2774 error ')' {$$ = AslDoError(); yyclearin;}
2775 ;
2776
2777 RegisterTerm
2778 : PARSEOP_REGISTER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_REGISTER);}
2779 AddressSpaceKeyword
2780 ',' ByteConstExpr
2781 ',' ByteConstExpr
2782 ',' QWordConstExpr
2783 OptionalAccessSize
2784 OptionalNameString_Last
2785 ')' {$$ = TrLinkChildren ($<n>3,6,$4,$6,$8,$10,$11,$12);}
2786 | PARSEOP_REGISTER '('
2787 error ')' {$$ = AslDoError(); yyclearin;}
2788 ;
2789
2790 StartDependentFnTerm
2791 : PARSEOP_STARTDEPENDENTFN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN);}
2792 ByteConstExpr
2793 ',' ByteConstExpr
2794 ')' '{'
2795 ResourceMacroList '}' {$$ = TrLinkChildren ($<n>3,3,$4,$6,$9);}
2796 | PARSEOP_STARTDEPENDENTFN '('
2797 error ')' {$$ = AslDoError(); yyclearin;}
2798 ;
2799
2800 StartDependentFnNoPriTerm
2801 : PARSEOP_STARTDEPENDENTFN_NOPRI '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STARTDEPENDENTFN_NOPRI);}
2802 ')' '{'
2803 ResourceMacroList '}' {$$ = TrLinkChildren ($<n>3,1,$6);}
2804 | PARSEOP_STARTDEPENDENTFN_NOPRI '('
2805 error ')' {$$ = AslDoError(); yyclearin;}
2806 ;
2807
2808 VendorLongTerm
2809 : PARSEOP_VENDORLONG '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORLONG);}
2810 OptionalNameString_First
2811 ')' '{'
2812 ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
2813 | PARSEOP_VENDORLONG '('
2814 error ')' {$$ = AslDoError(); yyclearin;}
2815 ;
2816
2817 VendorShortTerm
2818 : PARSEOP_VENDORSHORT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_VENDORSHORT);}
2819 OptionalNameString_First
2820 ')' '{'
2821 ByteList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
2822 | PARSEOP_VENDORSHORT '('
2823 error ')' {$$ = AslDoError(); yyclearin;}
2824 ;
2825
2826 WordBusNumberTerm
2827 : PARSEOP_WORDBUSNUMBER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDBUSNUMBER);}
2828 OptionalResourceType_First
2829 OptionalMinType
2830 OptionalMaxType
2831 OptionalDecodeType
2832 ',' WordConstExpr
2833 ',' WordConstExpr
2834 ',' WordConstExpr
2835 ',' WordConstExpr
2836 ',' WordConstExpr
2837 OptionalByteConstExpr
2838 OptionalStringData
2839 OptionalNameString_Last
2840 ')' {$$ = TrLinkChildren ($<n>3,12,$4,$5,$6,$7,$9,$11,$13,$15,$17,$18,$19,$20);}
2841 | PARSEOP_WORDBUSNUMBER '('
2842 error ')' {$$ = AslDoError(); yyclearin;}
2843 ;
2844
2845 WordIOTerm
2846 : PARSEOP_WORDIO '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDIO);}
2847 OptionalResourceType_First
2848 OptionalMinType
2849 OptionalMaxType
2850 OptionalDecodeType
2851 OptionalRangeType
2852 ',' WordConstExpr
2853 ',' WordConstExpr
2854 ',' WordConstExpr
2855 ',' WordConstExpr
2856 ',' WordConstExpr
2857 OptionalByteConstExpr
2858 OptionalStringData
2859 OptionalNameString
2860 OptionalType
2861 OptionalTranslationType_Last
2862 ')' {$$ = TrLinkChildren ($<n>3,15,$4,$5,$6,$7,$8,$10,$12,$14,$16,$18,$19,$20,$21,$22,$23);}
2863 | PARSEOP_WORDIO '('
2864 error ')' {$$ = AslDoError(); yyclearin;}
2865 ;
2866
2867 WordSpaceTerm
2868 : PARSEOP_WORDSPACE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WORDSPACE);}
2869 ByteConstExpr {UtCheckIntegerRange ($4, 0xC0, 0xFF);}
2870 OptionalResourceType
2871 OptionalDecodeType
2872 OptionalMinType
2873 OptionalMaxType
2874 ',' ByteConstExpr
2875 ',' WordConstExpr
2876 ',' WordConstExpr
2877 ',' WordConstExpr
2878 ',' WordConstExpr
2879 ',' WordConstExpr
2880 OptionalByteConstExpr
2881 OptionalStringData
2882 OptionalNameString_Last
2883 ')' {$$ = TrLinkChildren ($<n>3,14,$4,$6,$7,$8,$9,$11,$13,$15,$17,$19,$21,$22,$23,$24);}
2884 | PARSEOP_WORDSPACE '('
2885 error ')' {$$ = AslDoError(); yyclearin;}
2886 ;
2887
2888
2889 /******* Object References ***********************************************/
2890
2891 /* Allow IO, DMA, IRQ Resource macro names to also be used as identifiers */
2892
2893 NameString
2894 : NameSeg {}
2895 | PARSEOP_NAMESTRING {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) AslCompilerlval.s);}
2896 | PARSEOP_IO {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IO");}
2897 | PARSEOP_DMA {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "DMA");}
2898 | PARSEOP_IRQ {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESTRING, (ACPI_NATIVE_INT) "IRQ");}
2899 ;
2900
2901 NameSeg
2902 : PARSEOP_NAMESEG {$$ = TrCreateValuedLeafNode (PARSEOP_NAMESEG, (ACPI_NATIVE_INT) AslCompilerlval.s);}
2903 ;
2904
2905
2906 /******* Helper rules ****************************************************/
2907
2908
2909 AmlPackageLengthTerm
2910 : Integer {$$ = TrUpdateNode (PARSEOP_PACKAGE_LENGTH,(ACPI_PARSE_OBJECT *) $1);}
2911 ;
2912
2913 OptionalBusMasterKeyword
2914 : ',' {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
2915 | ',' PARSEOP_BUSMASTERTYPE_MASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_MASTER);}
2916 | ',' PARSEOP_BUSMASTERTYPE_NOTMASTER {$$ = TrCreateLeafNode (PARSEOP_BUSMASTERTYPE_NOTMASTER);}
2917 ;
2918
2919 OptionalAccessAttribTerm
2920 : {$$ = NULL;}
2921 | ',' {$$ = NULL;}
2922 | ',' ByteConstExpr {$$ = $2;}
2923 | ',' AccessAttribKeyword {$$ = $2;}
2924 ;
2925
2926 OptionalAccessSize
2927 : {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);}
2928 | ',' {$$ = TrCreateValuedLeafNode (PARSEOP_BYTECONST, 0);}
2929 | ',' ByteConstExpr {$$ = $2;}
2930 ;
2931
2932 OptionalAddressRange
2933 : {$$ = NULL;}
2934 | ',' {$$ = NULL;}
2935 | ',' AddressKeyword {$$ = $2;}
2936 ;
2937
2938 OptionalByteConstExpr
2939 : {$$ = NULL;}
2940 | ',' {$$ = NULL;}
2941 | ',' ByteConstExpr {$$ = $2;}
2942 ;
2943
2944 OptionalDecodeType
2945 : ',' {$$ = NULL;}
2946 | ',' DecodeKeyword {$$ = $2;}
2947 ;
2948
2949 OptionalDWordConstExpr
2950 : {$$ = NULL;}
2951 | ',' {$$ = NULL;}
2952 | ',' DWordConstExpr {$$ = $2;}
2953 ;
2954
2955 OptionalListString
2956 : {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */
2957 | ',' {$$ = TrCreateValuedLeafNode (PARSEOP_STRING_LITERAL, ACPI_TO_INTEGER (""));} /* Placeholder is a NULL string */
2958 | ',' TermArg {$$ = $2;}
2959 ;
2960
2961 OptionalMaxType
2962 : ',' {$$ = NULL;}
2963 | ',' MaxKeyword {$$ = $2;}
2964 ;
2965
2966 OptionalMemType
2967 : ',' {$$ = NULL;}
2968 | ',' MemTypeKeyword {$$ = $2;}
2969 ;
2970
2971 OptionalMinType
2972 : ',' {$$ = NULL;}
2973 | ',' MinKeyword {$$ = $2;}
2974 ;
2975
2976 OptionalNameString
2977 : {$$ = NULL;}
2978 | ',' {$$ = NULL;}
2979 | ',' NameString {$$ = $2;}
2980 ;
2981
2982 OptionalNameString_Last
2983 : {$$ = NULL;}
2984 | ',' {$$ = NULL;}
2985 | ',' NameString {$$ = $2;}
2986 ;
2987
2988 OptionalNameString_First
2989 : {$$ = TrCreateLeafNode (PARSEOP_ZERO);}
2990 | NameString {$$ = $1;}
2991 ;
2992
2993 OptionalObjectTypeKeyword
2994 : {$$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE_UNK);}
2995 | ',' ObjectTypeKeyword {$$ = $2;}
2996 ;
2997
2998 OptionalQWordConstExpr
2999 : {$$ = NULL;}
3000 | ',' {$$ = NULL;}
3001 | ',' QWordConstExpr {$$ = $2;}
3002 ;
3003
3004 OptionalRangeType
3005 : ',' {$$ = NULL;}
3006 | ',' RangeTypeKeyword {$$ = $2;}
3007 ;
3008
3009 OptionalReference
3010 : {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */
3011 | ',' {$$ = TrCreateLeafNode (PARSEOP_ZERO);} /* Placeholder is a ZeroOp object */
3012 | ',' TermArg {$$ = $2;}
3013 ;
3014
3015 OptionalResourceType_First
3016 : {$$ = NULL;}
3017 | ResourceTypeKeyword {$$ = $1;}
3018 ;
3019
3020 OptionalResourceType
3021 : ',' {$$ = NULL;}
3022 | ',' ResourceTypeKeyword {$$ = $2;}
3023 ;
3024
3025 OptionalSerializeRuleKeyword
3026 : {$$ = NULL;}
3027 | ',' {$$ = NULL;}
3028 | ',' SerializeRuleKeyword {$$ = $2;}
3029 ;
3030
3031 OptionalShareType
3032 : {$$ = NULL;}
3033 | ',' {$$ = NULL;}
3034 | ',' ShareTypeKeyword {$$ = $2;}
3035 ;
3036
3037 OptionalStringData
3038 : {$$ = NULL;}
3039 | ',' {$$ = NULL;}
3040 | ',' StringData {$$ = $2;}
3041 ;
3042
3043 OptionalTermArg
3044 : {$$ = NULL;}
3045 | TermArg {$$ = $1;}
3046 ;
3047
3048 OptionalReturnArg
3049 : {$$ = TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN);} /* Placeholder is a ZeroOp object */
3050 | TermArg {$$ = $1;}
3051 ;
3052
3053 OptionalType
3054 : {$$ = NULL;}
3055 | ',' {$$ = NULL;}
3056 | ',' TypeKeyword {$$ = $2;}
3057 ;
3058
3059 OptionalType_Last
3060 : {$$ = NULL;}
3061 | ',' {$$ = NULL;}
3062 | ',' TypeKeyword {$$ = $2;}
3063 ;
3064
3065 OptionalTranslationType_Last
3066 : {$$ = NULL;}
3067 | ',' {$$ = NULL;}
3068 | ',' TranslationKeyword {$$ = $2;}
3069 ;
3070
3071
3072 TermArgItem
3073 : ',' TermArg {$$ = $2;}
3074 | ',' error {$$ = AslDoError (); yyclearin;}
3075 ;
3076
3077 NameStringItem
3078 : ',' NameString {$$ = $2;}
3079 | ',' error {$$ = AslDoError (); yyclearin;}
3080 ;
3081
3082 %%
3083
3084
3085 /*
3086 * Local support functions
3087 */
3088
3089 int
3090 AslCompilerwrap(void)
3091 {
3092 return 1;
3093 }
3094
3095 /*! [End] no source code translation !*/
3096
3097 void *
AslLocalAllocate(unsigned int Size)3098 AslLocalAllocate (unsigned int Size)
3099 {
3100 void *Mem;
3101
3102
3103 DbgPrint (ASL_PARSE_OUTPUT, "\nAslLocalAllocate: Expanding Stack to %u\n\n", Size);
3104
3105 Mem = ACPI_ALLOCATE_ZEROED (Size);
3106 if (!Mem)
3107 {
3108 AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
3109 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
3110 Gbl_InputByteCount, Gbl_CurrentColumn,
3111 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
3112 exit (1);
3113 }
3114
3115 return (Mem);
3116 }
3117
3118 ACPI_PARSE_OBJECT *
AslDoError(void)3119 AslDoError (void)
3120 {
3121
3122
3123 return (TrCreateLeafNode (PARSEOP_ERRORNODE));
3124
3125 }
3126
3127
3128 /*******************************************************************************
3129 *
3130 * FUNCTION: UtGetOpName
3131 *
3132 * PARAMETERS: ParseOpcode - Parser keyword ID
3133 *
3134 * RETURN: Pointer to the opcode name
3135 *
3136 * DESCRIPTION: Get the ascii name of the parse opcode
3137 *
3138 ******************************************************************************/
3139
3140 char *
UtGetOpName(UINT32 ParseOpcode)3141 UtGetOpName (
3142 UINT32 ParseOpcode)
3143 {
3144 #ifdef ASL_YYTNAME_START
3145 /*
3146 * First entries (ASL_YYTNAME_START) in yytname are special reserved names.
3147 * Ignore first 8 characters of the name
3148 */
3149 return ((char *) yytname
3150 [(ParseOpcode - ASL_FIRST_PARSE_OPCODE) + ASL_YYTNAME_START] + 8);
3151 #else
3152 return ("[Unknown parser generator]");
3153 #endif
3154 }
3155