1
2%{
3/******************************************************************************
4 *
5 * Module Name: aslcompiler.l - Flex input file
6 * $Revision: 1.74 $
7 *
8 *****************************************************************************/
9
10/******************************************************************************
11 *
12 * 1. Copyright Notice
13 *
14 * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
15 * All rights reserved.
16 *
17 * 2. License
18 *
19 * 2.1. This is your license from Intel Corp. under its intellectual property
20 * rights. You may have additional license terms from the party that provided
21 * you this software, covering your right to use that party's intellectual
22 * property rights.
23 *
24 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
25 * copy of the source code appearing in this file ("Covered Code") an
26 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
27 * base code distributed originally by Intel ("Original Intel Code") to copy,
28 * make derivatives, distribute, use and display any portion of the Covered
29 * Code in any form, with the right to sublicense such rights; and
30 *
31 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
32 * license (with the right to sublicense), under only those claims of Intel
33 * patents that are infringed by the Original Intel Code, to make, use, sell,
34 * offer to sell, and import the Covered Code and derivative works thereof
35 * solely to the minimum extent necessary to exercise the above copyright
36 * license, and in no event shall the patent license extend to any additions
37 * to or modifications of the Original Intel Code. No other license or right
38 * is granted directly or by implication, estoppel or otherwise;
39 *
40 * The above copyright and patent license is granted only if the following
41 * conditions are met:
42 *
43 * 3. Conditions
44 *
45 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
46 * Redistribution of source code of any substantial portion of the Covered
47 * Code or modification with rights to further distribute source must include
48 * the above Copyright Notice, the above License, this list of Conditions,
49 * and the following Disclaimer and Export Compliance provision. In addition,
50 * Licensee must cause all Covered Code to which Licensee contributes to
51 * contain a file documenting the changes Licensee made to create that Covered
52 * Code and the date of any change. Licensee must include in that file the
53 * documentation of any changes made by any predecessor Licensee. Licensee
54 * must include a prominent statement that the modification is derived,
55 * directly or indirectly, from Original Intel Code.
56 *
57 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
58 * Redistribution of source code of any substantial portion of the Covered
59 * Code or modification without rights to further distribute source must
60 * include the following Disclaimer and Export Compliance provision in the
61 * documentation and/or other materials provided with distribution. In
62 * addition, Licensee may not authorize further sublicense of source of any
63 * portion of the Covered Code, and must include terms to the effect that the
64 * license from Licensee to its licensee is limited to the intellectual
65 * property embodied in the software Licensee provides to its licensee, and
66 * not to intellectual property embodied in modifications its licensee may
67 * make.
68 *
69 * 3.3. Redistribution of Executable. Redistribution in executable form of any
70 * substantial portion of the Covered Code or modification must reproduce the
71 * above Copyright Notice, and the following Disclaimer and Export Compliance
72 * provision in the documentation and/or other materials provided with the
73 * distribution.
74 *
75 * 3.4. Intel retains all right, title, and interest in and to the Original
76 * Intel Code.
77 *
78 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
79 * Intel shall be used in advertising or otherwise to promote the sale, use or
80 * other dealings in products derived from or relating to the Covered Code
81 * without prior written authorization from Intel.
82 *
83 * 4. Disclaimer and Export Compliance
84 *
85 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
86 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
87 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
88 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
89 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
90 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
91 * PARTICULAR PURPOSE.
92 *
93 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
94 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
95 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
96 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
97 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
98 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
99 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
100 * LIMITED REMEDY.
101 *
102 * 4.3. Licensee shall not export, either directly or indirectly, any of this
103 * software or system incorporating such software without first obtaining any
104 * required license or other approval from the U. S. Department of Commerce or
105 * any other agency or department of the United States Government. In the
106 * event Licensee exports any such software from the United States or
107 * re-exports any such software from a foreign destination, Licensee shall
108 * ensure that the distribution and export/re-export of the software is in
109 * compliance with all laws, regulations, orders, or other restrictions of the
110 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
111 * any of its subsidiaries will export/re-export any technical data, process,
112 * software, or service, directly or indirectly, to any country for which the
113 * United States government or any agency thereof requires an export license,
114 * other governmental approval, or letter of assurance, without first obtaining
115 * such license, approval or letter.
116 *
117 *****************************************************************************/
118
119
120#include <stdlib.h>
121#include <string.h>
122#include <contrib/dev/acpica/compiler/aslcompiler.h>
123#include "aslcompiler.y.h"
124YYSTYPE AslCompilerlval;
125
126/*
127 * Generation: Use the following command line:
128 *
129 * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath)
130 *
131 * -i: Scanner must be case-insensitive
132 */
133
134#define _COMPONENT ACPI_COMPILER
135 ACPI_MODULE_NAME ("aslscan")
136char
137comment (void);
138char
139comment2 (void);
140void
141count (int type);
142char
143literal (void);
144void
145copy (void);
146
147/*! [Begin] no source code translation */
148
149%}
150
151
152LeadNameChar [A-Za-z_]
153DigitChar [0-9]
154HexDigitChar [A-Fa-f0-9]
155RootChar [\\]
156Nothing []
157
158NameChar [A-Za-z_0-9]
159NameSeg1 {LeadNameChar}{NameChar}
160NameSeg2 {LeadNameChar}{NameChar}{NameChar}
161NameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar}
162NameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3}
163
164NameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath}
165NamePath {NonEmptyNamePath}?
166NonEmptyNamePath {NameSeg}{NamePathTail}*
167NamePathTail [.]{NameSeg}
168
169%%
170
171[ ] { count (0); }
172[\n] { count (0); }
173[ \t] { count (0); }
174
175
176"/*" { if (!comment ()) yyterminate (); }
177"//" { if (!comment2 ()) yyterminate (); }
178
179"\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); }
180
181
1820[xX]{HexDigitChar}+ |
183{DigitChar}+ { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext);
184 count (1); return (PARSEOP_INTEGER); }
185
186"Include" { count (1); return (PARSEOP_INCLUDE); }
187"#include" { count (1); return (PARSEOP_INCLUDE_CSTYLE); }
188"#line" { count (1); return (PARSEOP_LINE_CSTYLE); }
189"External" { count (1); return (PARSEOP_EXTERNAL); }
190
191
192"Ones" { count (1); return (PARSEOP_ONES); }
193"One" { count (1); return (PARSEOP_ONE); }
194"Zero" { count (1); return (PARSEOP_ZERO); }
195"Revision" { count (1); return (PARSEOP_REVISION); }
196
197"Offset" { count (1); return (PARSEOP_OFFSET); }
198"AccessAs" { count (1); return (PARSEOP_ACCESSAS); }
199"BankField" { count (2); return (PARSEOP_BANKFIELD); }
200"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); }
201"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); }
202"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); }
203"CreateField" { count (2); return (PARSEOP_CREATEFIELD); }
204"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); }
205"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); }
206"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); }
207"Device" { count (2); return (PARSEOP_DEVICE); }
208"Event" { count (2); return (PARSEOP_EVENT); }
209"Field" { count (2); return (PARSEOP_FIELD); }
210"Function" { count (2); return (PARSEOP_FUNCTION); }
211"IndexField" { count (2); return (PARSEOP_INDEXFIELD); }
212"Method" { count (2); return (PARSEOP_METHOD); }
213"Mutex" { count (2); return (PARSEOP_MUTEX); }
214"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); }
215"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); }
216"Processor" { count (2); return (PARSEOP_PROCESSOR); }
217"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); }
218"Alias" { count (2); return (PARSEOP_ALIAS); }
219"Name" { count (2); return (PARSEOP_NAME); }
220"Scope" { count (2); return (PARSEOP_SCOPE); }
221"Break" { count (3); return (PARSEOP_BREAK); }
222"BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); }
223"Continue" { count (3); return (PARSEOP_CONTINUE); }
224"Fatal" { count (3); return (PARSEOP_FATAL); }
225"If" { count (3); return (PARSEOP_IF); }
226"Else" { count (3); return (PARSEOP_ELSE); }
227"ElseIf" { count (3); return (PARSEOP_ELSEIF); }
228"Load" { count (3); return (PARSEOP_LOAD); }
229"Noop" { count (3); return (PARSEOP_NOOP); }
230"Notify" { count (3); return (PARSEOP_NOTIFY); }
231"Release" { count (3); return (PARSEOP_RELEASE); }
232"Reset" { count (3); return (PARSEOP_RESET); }
233"Return" { count (3); return (PARSEOP_RETURN); }
234"Signal" { count (3); return (PARSEOP_SIGNAL); }
235"Sleep" { count (3); return (PARSEOP_SLEEP); }
236"Stall" { count (3); return (PARSEOP_STALL); }
237"Switch" { count (3); return (PARSEOP_SWITCH); }
238"Case" { count (3); return (PARSEOP_CASE); }
239"Default" { count (3); return (PARSEOP_DEFAULT); }
240"Unload" { count (3); return (PARSEOP_UNLOAD); }
241"While" { count (3); return (PARSEOP_WHILE); }
242
243"Acquire" { count (3); return (PARSEOP_ACQUIRE); }
244"Add" { count (3); return (PARSEOP_ADD); }
245"And" { count (3); return (PARSEOP_AND); }
246"Concatenate" { count (3); return (PARSEOP_CONCATENATE); }
247"ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); }
248"CondRefOf" { count (3); return (PARSEOP_CONDREFOF); }
249"CopyObject" { count (3); return (PARSEOP_COPYOBJECT); }
250"Decrement" { count (3); return (PARSEOP_DECREMENT); }
251"DeRefOf" { count (3); return (PARSEOP_DEREFOF); }
252"Divide" { count (3); return (PARSEOP_DIVIDE); }
253"FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); }
254"FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); }
255"FromBCD" { count (3); return (PARSEOP_FROMBCD); }
256"Increment" { count (3); return (PARSEOP_INCREMENT); }
257"Index" { count (3); return (PARSEOP_INDEX); }
258"LAnd" { count (3); return (PARSEOP_LAND); }
259"LEqual" { count (3); return (PARSEOP_LEQUAL); }
260"LGreater" { count (3); return (PARSEOP_LGREATER); }
261"LGreaterEqual" { count (3); return (PARSEOP_LGREATEREQUAL); }
262"LLess" { count (3); return (PARSEOP_LLESS); }
263"LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); }
264"LNot" { count (3); return (PARSEOP_LNOT); }
265"LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); }
266"LoadTable" { count (3); return (PARSEOP_LOADTABLE); }
267"LOr" { count (3); return (PARSEOP_LOR); }
268"Match" { count (3); return (PARSEOP_MATCH); }
269"Mid" { count (3); return (PARSEOP_MID); }
270"Mod" { count (3); return (PARSEOP_MOD); }
271"Multiply" { count (3); return (PARSEOP_MULTIPLY); }
272"NAnd" { count (3); return (PARSEOP_NAND); }
273"NOr" { count (3); return (PARSEOP_NOR); }
274"Not" { count (3); return (PARSEOP_NOT); }
275"ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); }
276"Or" { count (3); return (PARSEOP_OR); }
277"RefOf" { count (3); return (PARSEOP_REFOF); }
278"ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); }
279"ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); }
280"SizeOf" { count (3); return (PARSEOP_SIZEOF); }
281"Store" { count (3); return (PARSEOP_STORE); }
282"Subtract" { count (3); return (PARSEOP_SUBTRACT); }
283"Timer" { count (3); return (PARSEOP_TIMER); }
284"ToBCD" { count (3); return (PARSEOP_TOBCD); }
285"ToBuffer" { count (3); return (PARSEOP_TOBUFFER); }
286"ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); }
287"ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); }
288"ToInteger" { count (3); return (PARSEOP_TOINTEGER); }
289"ToString" { count (3); return (PARSEOP_TOSTRING); }
290"Wait" { count (3); return (PARSEOP_WAIT); }
291"XOr" { count (3); return (PARSEOP_XOR); }
292
293"Arg0" { count (1); return (PARSEOP_ARG0); }
294"Arg1" { count (1); return (PARSEOP_ARG1); }
295"Arg2" { count (1); return (PARSEOP_ARG2); }
296"Arg3" { count (1); return (PARSEOP_ARG3); }
297"Arg4" { count (1); return (PARSEOP_ARG4); }
298"Arg5" { count (1); return (PARSEOP_ARG5); }
299"Arg6" { count (1); return (PARSEOP_ARG6); }
300
301"Local0" { count (1); return (PARSEOP_LOCAL0); }
302"Local1" { count (1); return (PARSEOP_LOCAL1); }
303"Local2" { count (1); return (PARSEOP_LOCAL2); }
304"Local3" { count (1); return (PARSEOP_LOCAL3); }
305"Local4" { count (1); return (PARSEOP_LOCAL4); }
306"Local5" { count (1); return (PARSEOP_LOCAL5); }
307"Local6" { count (1); return (PARSEOP_LOCAL6); }
308"Local7" { count (1); return (PARSEOP_LOCAL7); }
309
310"Debug" { count (1); return (PARSEOP_DEBUG); }
311
312"DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); }
313"Buffer" { count (1); return (PARSEOP_BUFFER); }
314"Package" { count (1); return (PARSEOP_PACKAGE); }
315
316"EISAID" { count (1); return (PARSEOP_EISAID); }
317"ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); }
318"ToUUID" { count (1); return (PARSEOP_TOUUID); }
319"Unicode" { count (1); return (PARSEOP_UNICODE); }
320"DMA" { count (1); return (PARSEOP_DMA); }
321"DWordIO" { count (1); return (PARSEOP_DWORDIO); }
322"DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); }
323"DWordSpace" { count (1); return (PARSEOP_DWORDSPACE); }
324"EndDependentFn" { count (1); return (PARSEOP_ENDDEPENDENTFN); }
325"ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); }
326"ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); }
327"ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); }
328"FixedIO" { count (1); return (PARSEOP_FIXEDIO); }
329"Interrupt" { count (1); return (PARSEOP_INTERRUPT); }
330"IO" { count (1); return (PARSEOP_IO); }
331"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); }
332"IRQ" { count (1); return (PARSEOP_IRQ); }
333"Memory24" { count (1); return (PARSEOP_MEMORY24); }
334"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); }
335"Memory32" { count (1); return (PARSEOP_MEMORY32); }
336"QWordIO" { count (1); return (PARSEOP_QWORDIO); }
337"QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); }
338"QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); }
339"Register" { count (1); return (PARSEOP_REGISTER); }
340"StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); }
341"StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); }
342"VendorLong" { count (1); return (PARSEOP_VENDORLONG); }
343"VendorShort" { count (1); return (PARSEOP_VENDORSHORT); }
344"WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); }
345"WordIO" { count (1); return (PARSEOP_WORDIO); }
346"WordSpace" { count (1); return (PARSEOP_WORDSPACE); }
347
348"UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); }
349"IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); }
350"StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); }
351"BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); }
352"PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); }
353"FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); }
354"DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); }
355"EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); }
356"MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); }
357"MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); }
358"OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); }
359"PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); }
360"ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); }
361"ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); }
362"BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); }
363"DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); }
364
365"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
366"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
367"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
368"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
369"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
370"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
371
372"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); }
373"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
374
375"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
376"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); }
377"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
378
379"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
380"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
381
382"SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); }
383"SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); }
384"PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); }
385"EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); }
386"SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); }
387"SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); }
388"PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); }
389
390"FFixedHW" { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); }
391
392"SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
393"SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
394"SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
395"SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
396"SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
397"SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
398"SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
399
400"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); }
401"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
402"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); }
403"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); }
404"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); }
405"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); }
406
407"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
408"TypeA" { count (0); return (PARSEOP_DMATYPE_A); }
409"TypeB" { count (0); return (PARSEOP_DMATYPE_B); }
410"TypeF" { count (0); return (PARSEOP_DMATYPE_F); }
411
412"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
413"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
414
415"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); }
416"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); }
417"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); }
418
419"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
420"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
421
422"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); }
423"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
424
425"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); }
426"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
427
428"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); }
429"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); }
430
431"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
432"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
433"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
434
435"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
436"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
437"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
438"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
439
440"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
441"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
442
443"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); }
444"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); }
445
446"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
447"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
448
449"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); }
450"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
451
452"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); }
453"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); }
454
455"TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); }
456"TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); }
457
458"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
459"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
460
461"AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
462"AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
463"AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
464"AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
465
466
467"{" { count (0); return('{'); }
468"}" { count (0); return('}'); }
469"," { count (0); return(','); }
470"(" { count (0); return('('); }
471")" { count (0); return(')'); }
472
473
474{NameSeg} { char *s;
475 count (0);
476 s=malloc (ACPI_NAME_SIZE + 1);
477 if (strcmp (AslCompilertext, "\\"))
478 {
479 strcpy (s, "____");
480 AcpiUtStrupr (AslCompilertext);
481 }
482 memcpy (s, AslCompilertext, strlen (AslCompilertext));
483 AslCompilerlval.s = s;
484 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s);
485 return (PARSEOP_NAMESEG); }
486
487{NameString} { char *s;
488 count (0);
489 s=malloc (strlen (AslCompilertext)+1);
490 AcpiUtStrupr (AslCompilertext);
491 strcpy (s, AslCompilertext);
492 s[strlen (AslCompilertext)] = 0;
493 AslCompilerlval.s = s;
494 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s);
495 return (PARSEOP_NAMESTRING); }
496
497"*" |
498"/" { count (1);
499 AslCompilererror ("Parse error, expecting ASL keyword or name");}
500
501. { count (1);
502 sprintf (MsgBuffer,
503 "Invalid character (0x%2.2X), expecting ASL keyword or name",
504 *AslCompilertext);
505 AslCompilererror (MsgBuffer);}
506
507<<EOF>> { if (AslPopInputFileStack ())
508 yyterminate();
509 else
510 return (PARSEOP_INCLUDE_END);};
511
512%%
513
514/*! [End] no source code translation !*/
515
516typedef struct asl_file_node
517{
518 FILE *File;
519 UINT32 CurrentLineNumber;
520 YY_BUFFER_STATE State;
521 char *Filename;
522 struct asl_file_node *Next;
523
524} ASL_FILE_NODE;
525
526ASL_FILE_NODE *InputStack = NULL;
527
528
529/*******************************************************************************
530 *
531 * FUNCTION: AslPopInputFileStack
532 *
533 * PARAMETERS: None
534 *
535 * RETURN: 0 if a node was popped, -1 otherwise
536 *
537 * DESCRIPTION: Pop the top of the input file stack and point the parser to
538 * the saved parse buffer contained in the fnode. Also, set the
539 * global line counters to the saved values. This function is
540 * called when an include file reaches EOF.
541 *
542 ******************************************************************************/
543
544int
545AslPopInputFileStack (
546 void)
547{
548 ASL_FILE_NODE *Fnode;
549 FILE *InputFile = NULL;
550
551
552 Fnode = InputStack;
553 DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
554
555
556 if (!Fnode)
557 {
558 return -1;
559 }
560
561 /* Close the current include file */
562
563 fclose (yyin);
564
565 /* Update the top-of-stack */
566
567 InputStack = Fnode->Next;
568 InputFile = Fnode->File;
569
570 /* Reset global line counter and filename */
571
572 Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
573 Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
574
575 /* Point the parser to the popped file */
576
577 yy_delete_buffer (YY_CURRENT_BUFFER);
578 yy_switch_to_buffer (Fnode->State);
579
580 /* All done with this node */
581
582 ACPI_MEM_FREE (Fnode);
583 return 0;
584}
585
586
587/*******************************************************************************
588 *
589 * FUNCTION: AslPushInputFileStack
590 *
591 * PARAMETERS: InputFile - Open file pointer
592 * Filename - Name of the file
593 *
594 * RETURN: None
595 *
596 * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
597 * to this file. Called when an include file is successfully
598 * opened.
599 *
600 ******************************************************************************/
601
602void
603AslPushInputFileStack (
604 FILE *InputFile,
605 char *Filename)
606{
607 ASL_FILE_NODE *Fnode;
608 YY_BUFFER_STATE State;
609
610
611 /* Save the current state in an Fnode */
612
613 Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
614
615 Fnode->File = yyin;
616 Fnode->Next = InputStack;
617 Fnode->State = YY_CURRENT_BUFFER;
618 Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
619 Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
620
621 /* Push it on the stack */
622
623 InputStack = Fnode;
624
625 /* Point the parser to this file */
626
627 State = yy_create_buffer (InputFile, YY_BUF_SIZE);
628 yy_switch_to_buffer (State);
629
630 DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
631
632 /* Reset the global line count and filename */
633
634 Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
635 Gbl_CurrentLineNumber = 1;
636 yyin = InputFile;
637}
638
639
640/*******************************************************************************
641 *
642 * FUNCTION: ResetCurrentLineBuffer
643 *
644 * PARAMETERS: None
645 *
646 * RETURN: None
647 *
648 * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
649 *
650 ******************************************************************************/
651
652void
653ResetCurrentLineBuffer (
654 void)
655{
656
657 if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
658 {
659 FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
660 Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
661 }
662
663 Gbl_CurrentLineOffset += Gbl_CurrentColumn;
664 Gbl_CurrentColumn = 0;
665
666 Gbl_CurrentLineNumber++;
667 Gbl_LogicalLineNumber++;
668 Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
669}
670
671
672/*******************************************************************************
673 *
674 * FUNCTION: InsertLineBuffer
675 *
676 * PARAMETERS: SourceChar - One char from the input ASL source file
677 *
678 * RETURN: None
679 *
680 * DESCRIPTION: Put one character of the source file into the temp line buffer
681 *
682 ******************************************************************************/
683
684#define ASL_SPACES_PER_TAB 4
685
686void
687InsertLineBuffer (
688 int SourceChar)
689{
690 UINT32 i;
691 UINT32 Count = 1;
692
693
694 if (SourceChar == EOF)
695 {
696 return;
697 }
698
699 Gbl_InputByteCount++;
700
701 /* Handle tabs. Convert to spaces */
702
703 if (SourceChar == '\t')
704 {
705 SourceChar = ' ';
706 Count = ASL_SPACES_PER_TAB -
707 (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
708 }
709
710
711 for (i = 0; i < Count; i++)
712 {
713 Gbl_CurrentColumn++;
714
715 /* Insert the character into the line buffer */
716
717 *Gbl_LineBufPtr = (UINT8) SourceChar;
718 Gbl_LineBufPtr++;
719
720 if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1)))
721 {
722#if 0
723 /*
724 * Warning if we have split a long source line.
725 * <Probably overkill>
726 */
727 sprintf (MsgBuffer, "Max %d", ASL_LINE_BUFFER_SIZE);
728 AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
729 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
730 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
731 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
732#endif
733
734 ResetCurrentLineBuffer ();
735 }
736 else if (SourceChar == '\n')
737 {
738 /* End of line */
739
740 ResetCurrentLineBuffer ();
741 }
742 }
743}
744
745
746/*******************************************************************************
747 *
748 * FUNCTION: count
749 *
750 * PARAMETERS: yytext - Contains the matched keyword.
751 * Type - Keyword/Character type:
752 * 0 = anything except a keyword
753 * 1 = pseudo-keywords
754 * 2 = non-executable ASL keywords
755 * 3 = executable ASL keywords
756 *
757 * RETURN: None
758 *
759 * DESCRIPTION: Count keywords and put them into the line buffer
760 *
761 ******************************************************************************/
762
763void
764count (
765 int Type)
766{
767 int i;
768
769
770 switch (Type)
771 {
772 case 2:
773 TotalKeywords++;
774 TotalNamedObjects++;
775 break;
776
777 case 3:
778 TotalKeywords++;
779 TotalExecutableOpcodes++;
780 break;
781 }
782
783 for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
784 {
785 InsertLineBuffer (yytext[i]);
786 *Gbl_LineBufPtr = 0;
787 }
788}
789
790
791/*******************************************************************************
792 *
793 * FUNCTION: comment
794 *
795 * PARAMETERS: none
796 *
797 * RETURN: none
798 *
799 * DESCRIPTION: Process a standard comment.
800 *
801 ******************************************************************************/
802
803char
804comment (void)
805{
806 char c;
807 char c1 = 0;
808
809
810 InsertLineBuffer ('/');
811 InsertLineBuffer ('*');
812
813loop:
814
815 /* Eat chars until end-of-comment */
816
817 while ((c = (char) input()) != '*' && c != EOF)
818 {
819 InsertLineBuffer (c);
820 c1 = c;
821 }
822
823 if (c == EOF)
824 {
825 goto EarlyEOF;
826 }
827
828 /*
829 * Check for nested comment -- can help catch cases where a previous
830 * comment was accidently left unterminated
831 */
832 if ((c1 == '/') && (c == '*'))
833 {
834 AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
835 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
836 Gbl_InputByteCount, Gbl_CurrentColumn,
837 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
838 }
839
840 /* Comment is closed only if the NEXT character is a slash */
841
842 InsertLineBuffer (c);
843
844 if ((c1 = (char) input()) != '/' && c1 != EOF)
845 {
846 unput(c1);
847 goto loop;
848 }
849
850 if (c1 == EOF)
851 {
852 goto EarlyEOF;
853 }
854
855 InsertLineBuffer (c1);
856 return TRUE;
857
858
859EarlyEOF:
860 /*
861 * Premature End-Of-File
862 */
863 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
864 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
865 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
866 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
867 return (FALSE);
868}
869
870
871/*******************************************************************************
872 *
873 * FUNCTION: comment
874 *
875 * PARAMETERS: none
876 *
877 * RETURN: none
878 *
879 * DESCRIPTION: Process a new "//" comment.
880 *
881 ******************************************************************************/
882
883char
884comment2 (void)
885{
886 char c;
887
888
889 InsertLineBuffer ('/');
890 InsertLineBuffer ('/');
891
892 while ((c = (char) input()) != '\n' && c != EOF)
893 {
894 InsertLineBuffer (c);
895 }
896
897 if (c == EOF)
898 {
899 /* End of file is OK, change to newline. Let parser detect EOF later */
900
901 c = '\n';
902 }
903
904 InsertLineBuffer (c);
905 return (TRUE);
906}
907
908
909/*******************************************************************************
910 *
911 * FUNCTION: literal
912 *
913 * PARAMETERS: none
914 *
915 * RETURN: none
916 *
917 * DESCRIPTION: Process a string literal (surrounded by quotes)
918 *
919 ******************************************************************************/
920
921#define ASL_NORMAL_CHAR 0
922#define ASL_ESCAPE_SEQUENCE 1
923#define ASL_OCTAL_CONSTANT 2
924#define ASL_HEX_CONSTANT 3
925
926char
927literal (void)
928{
929 char *s = MsgBuffer;
930 char *CleanString;
931 char StringChar;
932 UINT32 State = ASL_NORMAL_CHAR;
933 UINT32 i = 0;
934 UINT8 Digit;
935 UINT8 StringLength = 0;
936 char ConvertBuffer[4];
937
938
939 /*
940 * Eat chars until end-of-literal.
941 * NOTE: Put back the original surrounding quotes into the
942 * source line buffer.
943 */
944 InsertLineBuffer ('\"');
945 while ((StringChar = (char) input()) != EOF)
946 {
947 StringLength++;
948 if (StringLength == ACPI_MAX_STRING_CONVERSION)
949 {
950 /* Emit error only once, but keep going */
951
952 AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
953 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
954 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
955 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
956 }
957
958 InsertLineBuffer (StringChar);
959
960DoCharacter:
961
962 switch (State)
963 {
964 case ASL_NORMAL_CHAR:
965
966 switch (StringChar)
967 {
968 case '\\':
969 /*
970 * Special handling for backslash-escape sequence. We will
971 * toss the backslash and translate the escape char(s).
972 */
973 State = ASL_ESCAPE_SEQUENCE;
974 continue;
975
976 case '\"':
977
978 /* String terminator */
979
980 goto CompletedString;
981 }
982 break;
983
984
985 case ASL_ESCAPE_SEQUENCE:
986
987 State = ASL_NORMAL_CHAR;
988 switch (StringChar)
989 {
990 case 'a':
991 StringChar = 0x07; /* BELL */
992 break;
993
994 case 'b':
995 StringChar = 0x08; /* BACKSPACE */
996 break;
997
998 case 'f':
999 StringChar = 0x0C; /* FORMFEED */
1000 break;
1001
1002 case 'n':
1003 StringChar = 0x0A; /* LINEFEED */
1004 break;
1005
1006 case 'r':
1007 StringChar = 0x0D; /* CARRIAGE RETURN*/
1008 break;
1009
1010 case 't':
1011 StringChar = 0x09; /* HORIZONTAL TAB */
1012 break;
1013
1014 case 'v':
1015 StringChar = 0x0B; /* VERTICAL TAB */
1016 break;
1017
1018 case 'x':
1019 State = ASL_HEX_CONSTANT;
1020 i = 0;
1021 continue;
1022
1023 case '\'': /* Single Quote */
1024 case '\"': /* Double Quote */
1025 case '\\': /* Backslash */
1026 break;
1027
1028 default:
1029
1030 /* Check for an octal digit (0-7) */
1031
1032 if (ACPI_IS_OCTAL_DIGIT (StringChar))
1033 {
1034 State = ASL_OCTAL_CONSTANT;
1035 ConvertBuffer[0] = StringChar;
1036 i = 1;
1037 continue;
1038 }
1039
1040 /* Unknown escape sequence issue warning, but use the character */
1041
1042 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
1043 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1044 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1045 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1046 break;
1047 }
1048 break;
1049
1050
1051 case ASL_OCTAL_CONSTANT:
1052
1053 /* Up to three octal digits allowed */
1054
1055 if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
1056 (i > 2))
1057 {
1058 /*
1059 * Reached end of the constant. Convert the assembled ASCII
1060 * string and resume processing of the next character
1061 */
1062 ConvertBuffer[i] = 0;
1063 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
1064
1065 /* Check for NULL or non-ascii character (ignore if so) */
1066
1067 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
1068 {
1069 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
1070 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1071 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1072 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1073 }
1074 else
1075 {
1076 *s = (char) Digit;
1077 s++;
1078 }
1079
1080 State = ASL_NORMAL_CHAR;
1081 goto DoCharacter;
1082 break;
1083 }
1084
1085 /* Append another digit of the constant */
1086
1087 ConvertBuffer[i] = StringChar;
1088 i++;
1089 continue;
1090
1091
1092 case ASL_HEX_CONSTANT:
1093
1094 /* Up to two hex digits allowed */
1095
1096 if (!ACPI_IS_XDIGIT (StringChar) ||
1097 (i > 1))
1098 {
1099 /*
1100 * Reached end of the constant. Convert the assembled ASCII
1101 * string and resume processing of the next character
1102 */
1103 ConvertBuffer[i] = 0;
1104 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
1105
1106 /* Check for NULL or non-ascii character (ignore if so) */
1107
1108 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
1109 {
1110 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
1111 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1112 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1113 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1114 }
1115 else
1116 {
1117 *s = (char) Digit;
1118 s++;
1119 }
1120
1121 State = ASL_NORMAL_CHAR;
1122 goto DoCharacter;
1123 break;
1124 }
1125
1126 /* Append another digit of the constant */
1127
1128 ConvertBuffer[i] = StringChar;
1129 i++;
1130 continue;
1131 }
1132
1133 /* Save the finished character */
1134
1135 *s = StringChar;
1136 s++;
1137 }
1138
1139 /*
1140 * Premature End-Of-File
1141 */
1142 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
1143 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1144 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1145 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1146 return (FALSE);
1147
1148
1149CompletedString:
1150 /*
1151 * Null terminate the input string and copy string to a new buffer
1152 */
1153 *s = 0;
1154
1155 CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
1156 if (!CleanString)
1157 {
1158 AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
1159 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1160 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1161 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1162 return (FALSE);
1163 }
1164
1165 ACPI_STRCPY (CleanString, MsgBuffer);
1166 AslCompilerlval.s = CleanString;
1167 return (TRUE);
1168}
1169
1170
2%{
3/******************************************************************************
4 *
5 * Module Name: aslcompiler.l - Flex input file
6 * $Revision: 1.74 $
7 *
8 *****************************************************************************/
9
10/******************************************************************************
11 *
12 * 1. Copyright Notice
13 *
14 * Some or all of this work - Copyright (c) 1999 - 2005, Intel Corp.
15 * All rights reserved.
16 *
17 * 2. License
18 *
19 * 2.1. This is your license from Intel Corp. under its intellectual property
20 * rights. You may have additional license terms from the party that provided
21 * you this software, covering your right to use that party's intellectual
22 * property rights.
23 *
24 * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
25 * copy of the source code appearing in this file ("Covered Code") an
26 * irrevocable, perpetual, worldwide license under Intel's copyrights in the
27 * base code distributed originally by Intel ("Original Intel Code") to copy,
28 * make derivatives, distribute, use and display any portion of the Covered
29 * Code in any form, with the right to sublicense such rights; and
30 *
31 * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
32 * license (with the right to sublicense), under only those claims of Intel
33 * patents that are infringed by the Original Intel Code, to make, use, sell,
34 * offer to sell, and import the Covered Code and derivative works thereof
35 * solely to the minimum extent necessary to exercise the above copyright
36 * license, and in no event shall the patent license extend to any additions
37 * to or modifications of the Original Intel Code. No other license or right
38 * is granted directly or by implication, estoppel or otherwise;
39 *
40 * The above copyright and patent license is granted only if the following
41 * conditions are met:
42 *
43 * 3. Conditions
44 *
45 * 3.1. Redistribution of Source with Rights to Further Distribute Source.
46 * Redistribution of source code of any substantial portion of the Covered
47 * Code or modification with rights to further distribute source must include
48 * the above Copyright Notice, the above License, this list of Conditions,
49 * and the following Disclaimer and Export Compliance provision. In addition,
50 * Licensee must cause all Covered Code to which Licensee contributes to
51 * contain a file documenting the changes Licensee made to create that Covered
52 * Code and the date of any change. Licensee must include in that file the
53 * documentation of any changes made by any predecessor Licensee. Licensee
54 * must include a prominent statement that the modification is derived,
55 * directly or indirectly, from Original Intel Code.
56 *
57 * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
58 * Redistribution of source code of any substantial portion of the Covered
59 * Code or modification without rights to further distribute source must
60 * include the following Disclaimer and Export Compliance provision in the
61 * documentation and/or other materials provided with distribution. In
62 * addition, Licensee may not authorize further sublicense of source of any
63 * portion of the Covered Code, and must include terms to the effect that the
64 * license from Licensee to its licensee is limited to the intellectual
65 * property embodied in the software Licensee provides to its licensee, and
66 * not to intellectual property embodied in modifications its licensee may
67 * make.
68 *
69 * 3.3. Redistribution of Executable. Redistribution in executable form of any
70 * substantial portion of the Covered Code or modification must reproduce the
71 * above Copyright Notice, and the following Disclaimer and Export Compliance
72 * provision in the documentation and/or other materials provided with the
73 * distribution.
74 *
75 * 3.4. Intel retains all right, title, and interest in and to the Original
76 * Intel Code.
77 *
78 * 3.5. Neither the name Intel nor any other trademark owned or controlled by
79 * Intel shall be used in advertising or otherwise to promote the sale, use or
80 * other dealings in products derived from or relating to the Covered Code
81 * without prior written authorization from Intel.
82 *
83 * 4. Disclaimer and Export Compliance
84 *
85 * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
86 * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
87 * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE,
88 * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY
89 * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY
90 * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
91 * PARTICULAR PURPOSE.
92 *
93 * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
94 * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
95 * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
96 * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
97 * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
98 * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS
99 * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
100 * LIMITED REMEDY.
101 *
102 * 4.3. Licensee shall not export, either directly or indirectly, any of this
103 * software or system incorporating such software without first obtaining any
104 * required license or other approval from the U. S. Department of Commerce or
105 * any other agency or department of the United States Government. In the
106 * event Licensee exports any such software from the United States or
107 * re-exports any such software from a foreign destination, Licensee shall
108 * ensure that the distribution and export/re-export of the software is in
109 * compliance with all laws, regulations, orders, or other restrictions of the
110 * U.S. Export Administration Regulations. Licensee agrees that neither it nor
111 * any of its subsidiaries will export/re-export any technical data, process,
112 * software, or service, directly or indirectly, to any country for which the
113 * United States government or any agency thereof requires an export license,
114 * other governmental approval, or letter of assurance, without first obtaining
115 * such license, approval or letter.
116 *
117 *****************************************************************************/
118
119
120#include <stdlib.h>
121#include <string.h>
122#include <contrib/dev/acpica/compiler/aslcompiler.h>
123#include "aslcompiler.y.h"
124YYSTYPE AslCompilerlval;
125
126/*
127 * Generation: Use the following command line:
128 *
129 * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath)
130 *
131 * -i: Scanner must be case-insensitive
132 */
133
134#define _COMPONENT ACPI_COMPILER
135 ACPI_MODULE_NAME ("aslscan")
136char
137comment (void);
138char
139comment2 (void);
140void
141count (int type);
142char
143literal (void);
144void
145copy (void);
146
147/*! [Begin] no source code translation */
148
149%}
150
151
152LeadNameChar [A-Za-z_]
153DigitChar [0-9]
154HexDigitChar [A-Fa-f0-9]
155RootChar [\\]
156Nothing []
157
158NameChar [A-Za-z_0-9]
159NameSeg1 {LeadNameChar}{NameChar}
160NameSeg2 {LeadNameChar}{NameChar}{NameChar}
161NameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar}
162NameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3}
163
164NameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath}
165NamePath {NonEmptyNamePath}?
166NonEmptyNamePath {NameSeg}{NamePathTail}*
167NamePathTail [.]{NameSeg}
168
169%%
170
171[ ] { count (0); }
172[\n] { count (0); }
173[ \t] { count (0); }
174
175
176"/*" { if (!comment ()) yyterminate (); }
177"//" { if (!comment2 ()) yyterminate (); }
178
179"\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); }
180
181
1820[xX]{HexDigitChar}+ |
183{DigitChar}+ { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext);
184 count (1); return (PARSEOP_INTEGER); }
185
186"Include" { count (1); return (PARSEOP_INCLUDE); }
187"#include" { count (1); return (PARSEOP_INCLUDE_CSTYLE); }
188"#line" { count (1); return (PARSEOP_LINE_CSTYLE); }
189"External" { count (1); return (PARSEOP_EXTERNAL); }
190
191
192"Ones" { count (1); return (PARSEOP_ONES); }
193"One" { count (1); return (PARSEOP_ONE); }
194"Zero" { count (1); return (PARSEOP_ZERO); }
195"Revision" { count (1); return (PARSEOP_REVISION); }
196
197"Offset" { count (1); return (PARSEOP_OFFSET); }
198"AccessAs" { count (1); return (PARSEOP_ACCESSAS); }
199"BankField" { count (2); return (PARSEOP_BANKFIELD); }
200"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); }
201"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); }
202"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); }
203"CreateField" { count (2); return (PARSEOP_CREATEFIELD); }
204"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); }
205"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); }
206"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); }
207"Device" { count (2); return (PARSEOP_DEVICE); }
208"Event" { count (2); return (PARSEOP_EVENT); }
209"Field" { count (2); return (PARSEOP_FIELD); }
210"Function" { count (2); return (PARSEOP_FUNCTION); }
211"IndexField" { count (2); return (PARSEOP_INDEXFIELD); }
212"Method" { count (2); return (PARSEOP_METHOD); }
213"Mutex" { count (2); return (PARSEOP_MUTEX); }
214"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); }
215"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); }
216"Processor" { count (2); return (PARSEOP_PROCESSOR); }
217"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); }
218"Alias" { count (2); return (PARSEOP_ALIAS); }
219"Name" { count (2); return (PARSEOP_NAME); }
220"Scope" { count (2); return (PARSEOP_SCOPE); }
221"Break" { count (3); return (PARSEOP_BREAK); }
222"BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); }
223"Continue" { count (3); return (PARSEOP_CONTINUE); }
224"Fatal" { count (3); return (PARSEOP_FATAL); }
225"If" { count (3); return (PARSEOP_IF); }
226"Else" { count (3); return (PARSEOP_ELSE); }
227"ElseIf" { count (3); return (PARSEOP_ELSEIF); }
228"Load" { count (3); return (PARSEOP_LOAD); }
229"Noop" { count (3); return (PARSEOP_NOOP); }
230"Notify" { count (3); return (PARSEOP_NOTIFY); }
231"Release" { count (3); return (PARSEOP_RELEASE); }
232"Reset" { count (3); return (PARSEOP_RESET); }
233"Return" { count (3); return (PARSEOP_RETURN); }
234"Signal" { count (3); return (PARSEOP_SIGNAL); }
235"Sleep" { count (3); return (PARSEOP_SLEEP); }
236"Stall" { count (3); return (PARSEOP_STALL); }
237"Switch" { count (3); return (PARSEOP_SWITCH); }
238"Case" { count (3); return (PARSEOP_CASE); }
239"Default" { count (3); return (PARSEOP_DEFAULT); }
240"Unload" { count (3); return (PARSEOP_UNLOAD); }
241"While" { count (3); return (PARSEOP_WHILE); }
242
243"Acquire" { count (3); return (PARSEOP_ACQUIRE); }
244"Add" { count (3); return (PARSEOP_ADD); }
245"And" { count (3); return (PARSEOP_AND); }
246"Concatenate" { count (3); return (PARSEOP_CONCATENATE); }
247"ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); }
248"CondRefOf" { count (3); return (PARSEOP_CONDREFOF); }
249"CopyObject" { count (3); return (PARSEOP_COPYOBJECT); }
250"Decrement" { count (3); return (PARSEOP_DECREMENT); }
251"DeRefOf" { count (3); return (PARSEOP_DEREFOF); }
252"Divide" { count (3); return (PARSEOP_DIVIDE); }
253"FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); }
254"FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); }
255"FromBCD" { count (3); return (PARSEOP_FROMBCD); }
256"Increment" { count (3); return (PARSEOP_INCREMENT); }
257"Index" { count (3); return (PARSEOP_INDEX); }
258"LAnd" { count (3); return (PARSEOP_LAND); }
259"LEqual" { count (3); return (PARSEOP_LEQUAL); }
260"LGreater" { count (3); return (PARSEOP_LGREATER); }
261"LGreaterEqual" { count (3); return (PARSEOP_LGREATEREQUAL); }
262"LLess" { count (3); return (PARSEOP_LLESS); }
263"LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); }
264"LNot" { count (3); return (PARSEOP_LNOT); }
265"LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); }
266"LoadTable" { count (3); return (PARSEOP_LOADTABLE); }
267"LOr" { count (3); return (PARSEOP_LOR); }
268"Match" { count (3); return (PARSEOP_MATCH); }
269"Mid" { count (3); return (PARSEOP_MID); }
270"Mod" { count (3); return (PARSEOP_MOD); }
271"Multiply" { count (3); return (PARSEOP_MULTIPLY); }
272"NAnd" { count (3); return (PARSEOP_NAND); }
273"NOr" { count (3); return (PARSEOP_NOR); }
274"Not" { count (3); return (PARSEOP_NOT); }
275"ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); }
276"Or" { count (3); return (PARSEOP_OR); }
277"RefOf" { count (3); return (PARSEOP_REFOF); }
278"ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); }
279"ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); }
280"SizeOf" { count (3); return (PARSEOP_SIZEOF); }
281"Store" { count (3); return (PARSEOP_STORE); }
282"Subtract" { count (3); return (PARSEOP_SUBTRACT); }
283"Timer" { count (3); return (PARSEOP_TIMER); }
284"ToBCD" { count (3); return (PARSEOP_TOBCD); }
285"ToBuffer" { count (3); return (PARSEOP_TOBUFFER); }
286"ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); }
287"ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); }
288"ToInteger" { count (3); return (PARSEOP_TOINTEGER); }
289"ToString" { count (3); return (PARSEOP_TOSTRING); }
290"Wait" { count (3); return (PARSEOP_WAIT); }
291"XOr" { count (3); return (PARSEOP_XOR); }
292
293"Arg0" { count (1); return (PARSEOP_ARG0); }
294"Arg1" { count (1); return (PARSEOP_ARG1); }
295"Arg2" { count (1); return (PARSEOP_ARG2); }
296"Arg3" { count (1); return (PARSEOP_ARG3); }
297"Arg4" { count (1); return (PARSEOP_ARG4); }
298"Arg5" { count (1); return (PARSEOP_ARG5); }
299"Arg6" { count (1); return (PARSEOP_ARG6); }
300
301"Local0" { count (1); return (PARSEOP_LOCAL0); }
302"Local1" { count (1); return (PARSEOP_LOCAL1); }
303"Local2" { count (1); return (PARSEOP_LOCAL2); }
304"Local3" { count (1); return (PARSEOP_LOCAL3); }
305"Local4" { count (1); return (PARSEOP_LOCAL4); }
306"Local5" { count (1); return (PARSEOP_LOCAL5); }
307"Local6" { count (1); return (PARSEOP_LOCAL6); }
308"Local7" { count (1); return (PARSEOP_LOCAL7); }
309
310"Debug" { count (1); return (PARSEOP_DEBUG); }
311
312"DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); }
313"Buffer" { count (1); return (PARSEOP_BUFFER); }
314"Package" { count (1); return (PARSEOP_PACKAGE); }
315
316"EISAID" { count (1); return (PARSEOP_EISAID); }
317"ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); }
318"ToUUID" { count (1); return (PARSEOP_TOUUID); }
319"Unicode" { count (1); return (PARSEOP_UNICODE); }
320"DMA" { count (1); return (PARSEOP_DMA); }
321"DWordIO" { count (1); return (PARSEOP_DWORDIO); }
322"DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); }
323"DWordSpace" { count (1); return (PARSEOP_DWORDSPACE); }
324"EndDependentFn" { count (1); return (PARSEOP_ENDDEPENDENTFN); }
325"ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); }
326"ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); }
327"ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); }
328"FixedIO" { count (1); return (PARSEOP_FIXEDIO); }
329"Interrupt" { count (1); return (PARSEOP_INTERRUPT); }
330"IO" { count (1); return (PARSEOP_IO); }
331"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); }
332"IRQ" { count (1); return (PARSEOP_IRQ); }
333"Memory24" { count (1); return (PARSEOP_MEMORY24); }
334"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); }
335"Memory32" { count (1); return (PARSEOP_MEMORY32); }
336"QWordIO" { count (1); return (PARSEOP_QWORDIO); }
337"QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); }
338"QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); }
339"Register" { count (1); return (PARSEOP_REGISTER); }
340"StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); }
341"StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); }
342"VendorLong" { count (1); return (PARSEOP_VENDORLONG); }
343"VendorShort" { count (1); return (PARSEOP_VENDORSHORT); }
344"WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); }
345"WordIO" { count (1); return (PARSEOP_WORDIO); }
346"WordSpace" { count (1); return (PARSEOP_WORDSPACE); }
347
348"UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); }
349"IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); }
350"StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); }
351"BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); }
352"PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); }
353"FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); }
354"DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); }
355"EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); }
356"MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); }
357"MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); }
358"OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); }
359"PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); }
360"ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); }
361"ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); }
362"BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); }
363"DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); }
364
365"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
366"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
367"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
368"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
369"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
370"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
371
372"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); }
373"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
374
375"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
376"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); }
377"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
378
379"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
380"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
381
382"SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); }
383"SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); }
384"PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); }
385"EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); }
386"SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); }
387"SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); }
388"PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); }
389
390"FFixedHW" { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); }
391
392"SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
393"SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
394"SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
395"SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
396"SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
397"SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
398"SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
399
400"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); }
401"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
402"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); }
403"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); }
404"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); }
405"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); }
406
407"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
408"TypeA" { count (0); return (PARSEOP_DMATYPE_A); }
409"TypeB" { count (0); return (PARSEOP_DMATYPE_B); }
410"TypeF" { count (0); return (PARSEOP_DMATYPE_F); }
411
412"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
413"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
414
415"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); }
416"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); }
417"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); }
418
419"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
420"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
421
422"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); }
423"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
424
425"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); }
426"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
427
428"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); }
429"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); }
430
431"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
432"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
433"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
434
435"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
436"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
437"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
438"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
439
440"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
441"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
442
443"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); }
444"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); }
445
446"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
447"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
448
449"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); }
450"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
451
452"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); }
453"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); }
454
455"TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); }
456"TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); }
457
458"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
459"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
460
461"AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
462"AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
463"AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
464"AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
465
466
467"{" { count (0); return('{'); }
468"}" { count (0); return('}'); }
469"," { count (0); return(','); }
470"(" { count (0); return('('); }
471")" { count (0); return(')'); }
472
473
474{NameSeg} { char *s;
475 count (0);
476 s=malloc (ACPI_NAME_SIZE + 1);
477 if (strcmp (AslCompilertext, "\\"))
478 {
479 strcpy (s, "____");
480 AcpiUtStrupr (AslCompilertext);
481 }
482 memcpy (s, AslCompilertext, strlen (AslCompilertext));
483 AslCompilerlval.s = s;
484 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s);
485 return (PARSEOP_NAMESEG); }
486
487{NameString} { char *s;
488 count (0);
489 s=malloc (strlen (AslCompilertext)+1);
490 AcpiUtStrupr (AslCompilertext);
491 strcpy (s, AslCompilertext);
492 s[strlen (AslCompilertext)] = 0;
493 AslCompilerlval.s = s;
494 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s);
495 return (PARSEOP_NAMESTRING); }
496
497"*" |
498"/" { count (1);
499 AslCompilererror ("Parse error, expecting ASL keyword or name");}
500
501. { count (1);
502 sprintf (MsgBuffer,
503 "Invalid character (0x%2.2X), expecting ASL keyword or name",
504 *AslCompilertext);
505 AslCompilererror (MsgBuffer);}
506
507<<EOF>> { if (AslPopInputFileStack ())
508 yyterminate();
509 else
510 return (PARSEOP_INCLUDE_END);};
511
512%%
513
514/*! [End] no source code translation !*/
515
516typedef struct asl_file_node
517{
518 FILE *File;
519 UINT32 CurrentLineNumber;
520 YY_BUFFER_STATE State;
521 char *Filename;
522 struct asl_file_node *Next;
523
524} ASL_FILE_NODE;
525
526ASL_FILE_NODE *InputStack = NULL;
527
528
529/*******************************************************************************
530 *
531 * FUNCTION: AslPopInputFileStack
532 *
533 * PARAMETERS: None
534 *
535 * RETURN: 0 if a node was popped, -1 otherwise
536 *
537 * DESCRIPTION: Pop the top of the input file stack and point the parser to
538 * the saved parse buffer contained in the fnode. Also, set the
539 * global line counters to the saved values. This function is
540 * called when an include file reaches EOF.
541 *
542 ******************************************************************************/
543
544int
545AslPopInputFileStack (
546 void)
547{
548 ASL_FILE_NODE *Fnode;
549 FILE *InputFile = NULL;
550
551
552 Fnode = InputStack;
553 DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
554
555
556 if (!Fnode)
557 {
558 return -1;
559 }
560
561 /* Close the current include file */
562
563 fclose (yyin);
564
565 /* Update the top-of-stack */
566
567 InputStack = Fnode->Next;
568 InputFile = Fnode->File;
569
570 /* Reset global line counter and filename */
571
572 Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
573 Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
574
575 /* Point the parser to the popped file */
576
577 yy_delete_buffer (YY_CURRENT_BUFFER);
578 yy_switch_to_buffer (Fnode->State);
579
580 /* All done with this node */
581
582 ACPI_MEM_FREE (Fnode);
583 return 0;
584}
585
586
587/*******************************************************************************
588 *
589 * FUNCTION: AslPushInputFileStack
590 *
591 * PARAMETERS: InputFile - Open file pointer
592 * Filename - Name of the file
593 *
594 * RETURN: None
595 *
596 * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
597 * to this file. Called when an include file is successfully
598 * opened.
599 *
600 ******************************************************************************/
601
602void
603AslPushInputFileStack (
604 FILE *InputFile,
605 char *Filename)
606{
607 ASL_FILE_NODE *Fnode;
608 YY_BUFFER_STATE State;
609
610
611 /* Save the current state in an Fnode */
612
613 Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
614
615 Fnode->File = yyin;
616 Fnode->Next = InputStack;
617 Fnode->State = YY_CURRENT_BUFFER;
618 Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
619 Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
620
621 /* Push it on the stack */
622
623 InputStack = Fnode;
624
625 /* Point the parser to this file */
626
627 State = yy_create_buffer (InputFile, YY_BUF_SIZE);
628 yy_switch_to_buffer (State);
629
630 DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
631
632 /* Reset the global line count and filename */
633
634 Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
635 Gbl_CurrentLineNumber = 1;
636 yyin = InputFile;
637}
638
639
640/*******************************************************************************
641 *
642 * FUNCTION: ResetCurrentLineBuffer
643 *
644 * PARAMETERS: None
645 *
646 * RETURN: None
647 *
648 * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
649 *
650 ******************************************************************************/
651
652void
653ResetCurrentLineBuffer (
654 void)
655{
656
657 if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
658 {
659 FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
660 Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
661 }
662
663 Gbl_CurrentLineOffset += Gbl_CurrentColumn;
664 Gbl_CurrentColumn = 0;
665
666 Gbl_CurrentLineNumber++;
667 Gbl_LogicalLineNumber++;
668 Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
669}
670
671
672/*******************************************************************************
673 *
674 * FUNCTION: InsertLineBuffer
675 *
676 * PARAMETERS: SourceChar - One char from the input ASL source file
677 *
678 * RETURN: None
679 *
680 * DESCRIPTION: Put one character of the source file into the temp line buffer
681 *
682 ******************************************************************************/
683
684#define ASL_SPACES_PER_TAB 4
685
686void
687InsertLineBuffer (
688 int SourceChar)
689{
690 UINT32 i;
691 UINT32 Count = 1;
692
693
694 if (SourceChar == EOF)
695 {
696 return;
697 }
698
699 Gbl_InputByteCount++;
700
701 /* Handle tabs. Convert to spaces */
702
703 if (SourceChar == '\t')
704 {
705 SourceChar = ' ';
706 Count = ASL_SPACES_PER_TAB -
707 (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
708 }
709
710
711 for (i = 0; i < Count; i++)
712 {
713 Gbl_CurrentColumn++;
714
715 /* Insert the character into the line buffer */
716
717 *Gbl_LineBufPtr = (UINT8) SourceChar;
718 Gbl_LineBufPtr++;
719
720 if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1)))
721 {
722#if 0
723 /*
724 * Warning if we have split a long source line.
725 * <Probably overkill>
726 */
727 sprintf (MsgBuffer, "Max %d", ASL_LINE_BUFFER_SIZE);
728 AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
729 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
730 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
731 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
732#endif
733
734 ResetCurrentLineBuffer ();
735 }
736 else if (SourceChar == '\n')
737 {
738 /* End of line */
739
740 ResetCurrentLineBuffer ();
741 }
742 }
743}
744
745
746/*******************************************************************************
747 *
748 * FUNCTION: count
749 *
750 * PARAMETERS: yytext - Contains the matched keyword.
751 * Type - Keyword/Character type:
752 * 0 = anything except a keyword
753 * 1 = pseudo-keywords
754 * 2 = non-executable ASL keywords
755 * 3 = executable ASL keywords
756 *
757 * RETURN: None
758 *
759 * DESCRIPTION: Count keywords and put them into the line buffer
760 *
761 ******************************************************************************/
762
763void
764count (
765 int Type)
766{
767 int i;
768
769
770 switch (Type)
771 {
772 case 2:
773 TotalKeywords++;
774 TotalNamedObjects++;
775 break;
776
777 case 3:
778 TotalKeywords++;
779 TotalExecutableOpcodes++;
780 break;
781 }
782
783 for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
784 {
785 InsertLineBuffer (yytext[i]);
786 *Gbl_LineBufPtr = 0;
787 }
788}
789
790
791/*******************************************************************************
792 *
793 * FUNCTION: comment
794 *
795 * PARAMETERS: none
796 *
797 * RETURN: none
798 *
799 * DESCRIPTION: Process a standard comment.
800 *
801 ******************************************************************************/
802
803char
804comment (void)
805{
806 char c;
807 char c1 = 0;
808
809
810 InsertLineBuffer ('/');
811 InsertLineBuffer ('*');
812
813loop:
814
815 /* Eat chars until end-of-comment */
816
817 while ((c = (char) input()) != '*' && c != EOF)
818 {
819 InsertLineBuffer (c);
820 c1 = c;
821 }
822
823 if (c == EOF)
824 {
825 goto EarlyEOF;
826 }
827
828 /*
829 * Check for nested comment -- can help catch cases where a previous
830 * comment was accidently left unterminated
831 */
832 if ((c1 == '/') && (c == '*'))
833 {
834 AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
835 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
836 Gbl_InputByteCount, Gbl_CurrentColumn,
837 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
838 }
839
840 /* Comment is closed only if the NEXT character is a slash */
841
842 InsertLineBuffer (c);
843
844 if ((c1 = (char) input()) != '/' && c1 != EOF)
845 {
846 unput(c1);
847 goto loop;
848 }
849
850 if (c1 == EOF)
851 {
852 goto EarlyEOF;
853 }
854
855 InsertLineBuffer (c1);
856 return TRUE;
857
858
859EarlyEOF:
860 /*
861 * Premature End-Of-File
862 */
863 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
864 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
865 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
866 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
867 return (FALSE);
868}
869
870
871/*******************************************************************************
872 *
873 * FUNCTION: comment
874 *
875 * PARAMETERS: none
876 *
877 * RETURN: none
878 *
879 * DESCRIPTION: Process a new "//" comment.
880 *
881 ******************************************************************************/
882
883char
884comment2 (void)
885{
886 char c;
887
888
889 InsertLineBuffer ('/');
890 InsertLineBuffer ('/');
891
892 while ((c = (char) input()) != '\n' && c != EOF)
893 {
894 InsertLineBuffer (c);
895 }
896
897 if (c == EOF)
898 {
899 /* End of file is OK, change to newline. Let parser detect EOF later */
900
901 c = '\n';
902 }
903
904 InsertLineBuffer (c);
905 return (TRUE);
906}
907
908
909/*******************************************************************************
910 *
911 * FUNCTION: literal
912 *
913 * PARAMETERS: none
914 *
915 * RETURN: none
916 *
917 * DESCRIPTION: Process a string literal (surrounded by quotes)
918 *
919 ******************************************************************************/
920
921#define ASL_NORMAL_CHAR 0
922#define ASL_ESCAPE_SEQUENCE 1
923#define ASL_OCTAL_CONSTANT 2
924#define ASL_HEX_CONSTANT 3
925
926char
927literal (void)
928{
929 char *s = MsgBuffer;
930 char *CleanString;
931 char StringChar;
932 UINT32 State = ASL_NORMAL_CHAR;
933 UINT32 i = 0;
934 UINT8 Digit;
935 UINT8 StringLength = 0;
936 char ConvertBuffer[4];
937
938
939 /*
940 * Eat chars until end-of-literal.
941 * NOTE: Put back the original surrounding quotes into the
942 * source line buffer.
943 */
944 InsertLineBuffer ('\"');
945 while ((StringChar = (char) input()) != EOF)
946 {
947 StringLength++;
948 if (StringLength == ACPI_MAX_STRING_CONVERSION)
949 {
950 /* Emit error only once, but keep going */
951
952 AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
953 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
954 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
955 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
956 }
957
958 InsertLineBuffer (StringChar);
959
960DoCharacter:
961
962 switch (State)
963 {
964 case ASL_NORMAL_CHAR:
965
966 switch (StringChar)
967 {
968 case '\\':
969 /*
970 * Special handling for backslash-escape sequence. We will
971 * toss the backslash and translate the escape char(s).
972 */
973 State = ASL_ESCAPE_SEQUENCE;
974 continue;
975
976 case '\"':
977
978 /* String terminator */
979
980 goto CompletedString;
981 }
982 break;
983
984
985 case ASL_ESCAPE_SEQUENCE:
986
987 State = ASL_NORMAL_CHAR;
988 switch (StringChar)
989 {
990 case 'a':
991 StringChar = 0x07; /* BELL */
992 break;
993
994 case 'b':
995 StringChar = 0x08; /* BACKSPACE */
996 break;
997
998 case 'f':
999 StringChar = 0x0C; /* FORMFEED */
1000 break;
1001
1002 case 'n':
1003 StringChar = 0x0A; /* LINEFEED */
1004 break;
1005
1006 case 'r':
1007 StringChar = 0x0D; /* CARRIAGE RETURN*/
1008 break;
1009
1010 case 't':
1011 StringChar = 0x09; /* HORIZONTAL TAB */
1012 break;
1013
1014 case 'v':
1015 StringChar = 0x0B; /* VERTICAL TAB */
1016 break;
1017
1018 case 'x':
1019 State = ASL_HEX_CONSTANT;
1020 i = 0;
1021 continue;
1022
1023 case '\'': /* Single Quote */
1024 case '\"': /* Double Quote */
1025 case '\\': /* Backslash */
1026 break;
1027
1028 default:
1029
1030 /* Check for an octal digit (0-7) */
1031
1032 if (ACPI_IS_OCTAL_DIGIT (StringChar))
1033 {
1034 State = ASL_OCTAL_CONSTANT;
1035 ConvertBuffer[0] = StringChar;
1036 i = 1;
1037 continue;
1038 }
1039
1040 /* Unknown escape sequence issue warning, but use the character */
1041
1042 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
1043 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1044 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1045 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1046 break;
1047 }
1048 break;
1049
1050
1051 case ASL_OCTAL_CONSTANT:
1052
1053 /* Up to three octal digits allowed */
1054
1055 if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
1056 (i > 2))
1057 {
1058 /*
1059 * Reached end of the constant. Convert the assembled ASCII
1060 * string and resume processing of the next character
1061 */
1062 ConvertBuffer[i] = 0;
1063 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
1064
1065 /* Check for NULL or non-ascii character (ignore if so) */
1066
1067 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
1068 {
1069 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
1070 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1071 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1072 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1073 }
1074 else
1075 {
1076 *s = (char) Digit;
1077 s++;
1078 }
1079
1080 State = ASL_NORMAL_CHAR;
1081 goto DoCharacter;
1082 break;
1083 }
1084
1085 /* Append another digit of the constant */
1086
1087 ConvertBuffer[i] = StringChar;
1088 i++;
1089 continue;
1090
1091
1092 case ASL_HEX_CONSTANT:
1093
1094 /* Up to two hex digits allowed */
1095
1096 if (!ACPI_IS_XDIGIT (StringChar) ||
1097 (i > 1))
1098 {
1099 /*
1100 * Reached end of the constant. Convert the assembled ASCII
1101 * string and resume processing of the next character
1102 */
1103 ConvertBuffer[i] = 0;
1104 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
1105
1106 /* Check for NULL or non-ascii character (ignore if so) */
1107
1108 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
1109 {
1110 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
1111 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1112 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1113 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1114 }
1115 else
1116 {
1117 *s = (char) Digit;
1118 s++;
1119 }
1120
1121 State = ASL_NORMAL_CHAR;
1122 goto DoCharacter;
1123 break;
1124 }
1125
1126 /* Append another digit of the constant */
1127
1128 ConvertBuffer[i] = StringChar;
1129 i++;
1130 continue;
1131 }
1132
1133 /* Save the finished character */
1134
1135 *s = StringChar;
1136 s++;
1137 }
1138
1139 /*
1140 * Premature End-Of-File
1141 */
1142 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
1143 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1144 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1145 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1146 return (FALSE);
1147
1148
1149CompletedString:
1150 /*
1151 * Null terminate the input string and copy string to a new buffer
1152 */
1153 *s = 0;
1154
1155 CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
1156 if (!CleanString)
1157 {
1158 AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
1159 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1160 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1161 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1162 return (FALSE);
1163 }
1164
1165 ACPI_STRCPY (CleanString, MsgBuffer);
1166 AslCompilerlval.s = CleanString;
1167 return (TRUE);
1168}
1169
1170