3 /******************************************************************************
5 * Module Name: aslcompiler.l - Flex input file
7 *****************************************************************************/
10 * Copyright (C) 2000 - 2011, Intel Corp.
11 * All rights reserved.
13 * Redistribution and use in source and binary forms, with or without
14 * modification, are permitted provided that the following conditions
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.
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.
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.
46 #include <contrib/dev/acpica/compiler/aslcompiler.h>
47 #include "aslcompiler.y.h"
51 YYSTYPE AslCompilerlval;
54 * Generation: Use the following command line:
56 * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath)
58 * -i: Scanner must be case-insensitive
61 #define _COMPONENT ACPI_COMPILER
62 ACPI_MODULE_NAME ("aslscan")
74 /*! [Begin] no source code translation */
79 LeadNameChar [A-Za-z_]
81 HexDigitChar [A-Fa-f0-9]
86 NameSeg1 {LeadNameChar}{NameChar}
87 NameSeg2 {LeadNameChar}{NameChar}{NameChar}
88 NameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar}
89 NameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3}
91 NameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath}
92 NamePath {NonEmptyNamePath}?
93 NonEmptyNamePath {NameSeg}{NamePathTail}*
94 NamePathTail [.]{NameSeg}
99 [\n] { count (0); } /* Handle files with both LF and CR/LF */
100 [\r] { count (0); } /* termination on both Unix and Windows */
104 "/*" { if (!comment ()) yyterminate (); }
105 "//" { if (!comment2 ()) yyterminate (); }
107 "\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); }
110 0[xX]{HexDigitChar}+ |
111 {DigitChar}+ { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext);
112 count (1); return (PARSEOP_INTEGER); }
114 "Include" { count (1); return (PARSEOP_INCLUDE); }
115 "#include" { count (1); return (PARSEOP_INCLUDE_CSTYLE); }
116 "#line" { count (1); return (PARSEOP_LINE_CSTYLE); }
117 "External" { count (1); return (PARSEOP_EXTERNAL); }
120 "Ones" { count (1); return (PARSEOP_ONES); }
121 "One" { count (1); return (PARSEOP_ONE); }
122 "Zero" { count (1); return (PARSEOP_ZERO); }
123 "Revision" { count (1); return (PARSEOP_REVISION); }
125 "Offset" { count (1); return (PARSEOP_OFFSET); }
126 "AccessAs" { count (1); return (PARSEOP_ACCESSAS); }
127 "BankField" { count (2); return (PARSEOP_BANKFIELD); }
128 "CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); }
129 "CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); }
130 "CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); }
131 "CreateField" { count (2); return (PARSEOP_CREATEFIELD); }
132 "CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); }
133 "CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); }
134 "DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); }
135 "Device" { count (2); return (PARSEOP_DEVICE); }
136 "Event" { count (2); return (PARSEOP_EVENT); }
137 "Field" { count (2); return (PARSEOP_FIELD); }
138 "Function" { count (2); return (PARSEOP_FUNCTION); }
139 "IndexField" { count (2); return (PARSEOP_INDEXFIELD); }
140 "Method" { count (2); return (PARSEOP_METHOD); }
141 "Mutex" { count (2); return (PARSEOP_MUTEX); }
142 "OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); }
143 "PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); }
144 "Processor" { count (2); return (PARSEOP_PROCESSOR); }
145 "ThermalZone" { count (2); return (PARSEOP_THERMALZONE); }
146 "Alias" { count (2); return (PARSEOP_ALIAS); }
147 "Name" { count (2); return (PARSEOP_NAME); }
148 "Scope" { count (2); return (PARSEOP_SCOPE); }
149 "Break" { count (3); return (PARSEOP_BREAK); }
150 "BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); }
151 "Continue" { count (3); return (PARSEOP_CONTINUE); }
152 "Fatal" { count (3); return (PARSEOP_FATAL); }
153 "If" { count (3); return (PARSEOP_IF); }
154 "Else" { count (3); return (PARSEOP_ELSE); }
155 "ElseIf" { count (3); return (PARSEOP_ELSEIF); }
156 "Load" { count (3); return (PARSEOP_LOAD); }
157 "Noop" { count (3); return (PARSEOP_NOOP); }
158 "Notify" { count (3); return (PARSEOP_NOTIFY); }
159 "Release" { count (3); return (PARSEOP_RELEASE); }
160 "Reset" { count (3); return (PARSEOP_RESET); }
161 "Return" { count (3); return (PARSEOP_RETURN); }
162 "Signal" { count (3); return (PARSEOP_SIGNAL); }
163 "Sleep" { count (3); return (PARSEOP_SLEEP); }
164 "Stall" { count (3); return (PARSEOP_STALL); }
165 "Switch" { count (3); return (PARSEOP_SWITCH); }
166 "Case" { count (3); return (PARSEOP_CASE); }
167 "Default" { count (3); return (PARSEOP_DEFAULT); }
168 "Unload" { count (3); return (PARSEOP_UNLOAD); }
169 "While" { count (3); return (PARSEOP_WHILE); }
171 "Acquire" { count (3); return (PARSEOP_ACQUIRE); }
172 "Add" { count (3); return (PARSEOP_ADD); }
173 "And" { count (3); return (PARSEOP_AND); }
174 "Concatenate" { count (3); return (PARSEOP_CONCATENATE); }
175 "ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); }
176 "CondRefOf" { count (3); return (PARSEOP_CONDREFOF); }
177 "CopyObject" { count (3); return (PARSEOP_COPYOBJECT); }
178 "Decrement" { count (3); return (PARSEOP_DECREMENT); }
179 "DeRefOf" { count (3); return (PARSEOP_DEREFOF); }
180 "Divide" { count (3); return (PARSEOP_DIVIDE); }
181 "FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); }
182 "FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); }
183 "FromBCD" { count (3); return (PARSEOP_FROMBCD); }
184 "Increment" { count (3); return (PARSEOP_INCREMENT); }
185 "Index" { count (3); return (PARSEOP_INDEX); }
186 "LAnd" { count (3); return (PARSEOP_LAND); }
187 "LEqual" { count (3); return (PARSEOP_LEQUAL); }
188 "LGreater" { count (3); return (PARSEOP_LGREATER); }
189 "LGreaterEqual" { count (3); return (PARSEOP_LGREATEREQUAL); }
190 "LLess" { count (3); return (PARSEOP_LLESS); }
191 "LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); }
192 "LNot" { count (3); return (PARSEOP_LNOT); }
193 "LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); }
194 "LoadTable" { count (3); return (PARSEOP_LOADTABLE); }
195 "LOr" { count (3); return (PARSEOP_LOR); }
196 "Match" { count (3); return (PARSEOP_MATCH); }
197 "Mid" { count (3); return (PARSEOP_MID); }
198 "Mod" { count (3); return (PARSEOP_MOD); }
199 "Multiply" { count (3); return (PARSEOP_MULTIPLY); }
200 "NAnd" { count (3); return (PARSEOP_NAND); }
201 "NOr" { count (3); return (PARSEOP_NOR); }
202 "Not" { count (3); return (PARSEOP_NOT); }
203 "ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); }
204 "Or" { count (3); return (PARSEOP_OR); }
205 "RefOf" { count (3); return (PARSEOP_REFOF); }
206 "ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); }
207 "ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); }
208 "SizeOf" { count (3); return (PARSEOP_SIZEOF); }
209 "Store" { count (3); return (PARSEOP_STORE); }
210 "Subtract" { count (3); return (PARSEOP_SUBTRACT); }
211 "Timer" { count (3); return (PARSEOP_TIMER); }
212 "ToBCD" { count (3); return (PARSEOP_TOBCD); }
213 "ToBuffer" { count (3); return (PARSEOP_TOBUFFER); }
214 "ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); }
215 "ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); }
216 "ToInteger" { count (3); return (PARSEOP_TOINTEGER); }
217 "ToString" { count (3); return (PARSEOP_TOSTRING); }
218 "Wait" { count (3); return (PARSEOP_WAIT); }
219 "XOr" { count (3); return (PARSEOP_XOR); }
221 "Arg0" { count (1); return (PARSEOP_ARG0); }
222 "Arg1" { count (1); return (PARSEOP_ARG1); }
223 "Arg2" { count (1); return (PARSEOP_ARG2); }
224 "Arg3" { count (1); return (PARSEOP_ARG3); }
225 "Arg4" { count (1); return (PARSEOP_ARG4); }
226 "Arg5" { count (1); return (PARSEOP_ARG5); }
227 "Arg6" { count (1); return (PARSEOP_ARG6); }
229 "Local0" { count (1); return (PARSEOP_LOCAL0); }
230 "Local1" { count (1); return (PARSEOP_LOCAL1); }
231 "Local2" { count (1); return (PARSEOP_LOCAL2); }
232 "Local3" { count (1); return (PARSEOP_LOCAL3); }
233 "Local4" { count (1); return (PARSEOP_LOCAL4); }
234 "Local5" { count (1); return (PARSEOP_LOCAL5); }
235 "Local6" { count (1); return (PARSEOP_LOCAL6); }
236 "Local7" { count (1); return (PARSEOP_LOCAL7); }
238 "Debug" { count (1); return (PARSEOP_DEBUG); }
240 "DefinitionBlock" { count (1); return (PARSEOP_DEFINITIONBLOCK); }
241 "Buffer" { count (1); return (PARSEOP_BUFFER); }
242 "Package" { count (1); return (PARSEOP_PACKAGE); }
244 "EISAID" { count (1); return (PARSEOP_EISAID); }
245 "ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); }
246 "ToUUID" { count (1); return (PARSEOP_TOUUID); }
247 "Unicode" { count (1); return (PARSEOP_UNICODE); }
248 "DMA" { count (1); return (PARSEOP_DMA); }
249 "DWordIO" { count (1); return (PARSEOP_DWORDIO); }
250 "DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); }
251 "DWordSpace" { count (1); return (PARSEOP_DWORDSPACE); }
252 "EndDependentFn" { count (1); return (PARSEOP_ENDDEPENDENTFN); }
253 "ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); }
254 "ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); }
255 "ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); }
256 "FixedIO" { count (1); return (PARSEOP_FIXEDIO); }
257 "Interrupt" { count (1); return (PARSEOP_INTERRUPT); }
258 "IO" { count (1); return (PARSEOP_IO); }
259 "IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); }
260 "IRQ" { count (1); return (PARSEOP_IRQ); }
261 "Memory24" { count (1); return (PARSEOP_MEMORY24); }
262 "Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); }
263 "Memory32" { count (1); return (PARSEOP_MEMORY32); }
264 "QWordIO" { count (1); return (PARSEOP_QWORDIO); }
265 "QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); }
266 "QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); }
267 "Register" { count (1); return (PARSEOP_REGISTER); }
268 "StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); }
269 "StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); }
270 "VendorLong" { count (1); return (PARSEOP_VENDORLONG); }
271 "VendorShort" { count (1); return (PARSEOP_VENDORSHORT); }
272 "WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); }
273 "WordIO" { count (1); return (PARSEOP_WORDIO); }
274 "WordSpace" { count (1); return (PARSEOP_WORDSPACE); }
276 "UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); }
277 "IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); }
278 "StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); }
279 "BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); }
280 "PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); }
281 "FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); }
282 "DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); }
283 "EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); }
284 "MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); }
285 "MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); }
286 "OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); }
287 "PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); }
288 "ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); }
289 "ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); }
290 "BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); }
291 "DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); }
293 "AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); }
294 "ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); }
295 "WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); }
296 "DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); }
297 "QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); }
298 "BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); }
300 "Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); }
301 "NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); }
303 "Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); }
304 "WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); }
305 "WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); }
307 "Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); }
308 "NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); }
310 "SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); }
311 "SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); }
312 "PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); }
313 "EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); }
314 "SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); }
315 "SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); }
316 "PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); }
317 "IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); }
319 "FFixedHW" { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); }
321 "SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
322 "SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
323 "SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
324 "SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
325 "SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
326 "SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
327 "SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
329 "MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); }
330 "MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
331 "MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); }
332 "MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); }
333 "MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); }
334 "MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); }
336 "Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
337 "TypeA" { count (0); return (PARSEOP_DMATYPE_A); }
338 "TypeB" { count (0); return (PARSEOP_DMATYPE_B); }
339 "TypeF" { count (0); return (PARSEOP_DMATYPE_F); }
341 "BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
342 "NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
344 "Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); }
345 "Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); }
346 "Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); }
348 "ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
349 "ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
351 "MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); }
352 "MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
354 "MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); }
355 "MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
357 "PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); }
358 "SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); }
360 "ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
361 "NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
362 "EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
364 "Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
365 "WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
366 "Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
367 "NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
369 "ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
370 "ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
372 "Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); }
373 "Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); }
375 "ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
376 "ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
378 "Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); }
379 "Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
381 "Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); }
382 "Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); }
384 "TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); }
385 "TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); }
387 "SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
388 "DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
390 "AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
391 "AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
392 "AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
393 "AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
395 "__DATE__" { count (0); return (PARSEOP___DATE__); }
396 "__FILE__" { count (0); return (PARSEOP___FILE__); }
397 "__LINE__" { count (0); return (PARSEOP___LINE__); }
399 "{" { count (0); return('{'); }
400 "}" { count (0); return('}'); }
401 "," { count (0); return(','); }
402 "(" { count (0); return('('); }
403 ")" { count (0); return(')'); }
408 s=malloc (ACPI_NAME_SIZE + 1);
409 if (strcmp (AslCompilertext, "\\"))
412 AcpiUtStrupr (AslCompilertext);
414 memcpy (s, AslCompilertext, strlen (AslCompilertext));
415 AslCompilerlval.s = s;
416 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s);
417 return (PARSEOP_NAMESEG); }
419 {NameString} { char *s;
421 s=malloc (strlen (AslCompilertext)+1);
422 AcpiUtStrupr (AslCompilertext);
423 strcpy (s, AslCompilertext);
424 s[strlen (AslCompilertext)] = 0;
425 AslCompilerlval.s = s;
426 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s);
427 return (PARSEOP_NAMESTRING); }
431 AslCompilererror ("Parse error, expecting ASL keyword or name");}
435 "Invalid character (0x%2.2X), expecting ASL keyword or name",
437 AslCompilererror (MsgBuffer);}
439 <<EOF>> { if (AslPopInputFileStack ())
442 return (PARSEOP_INCLUDE_END);};
446 /*! [End] no source code translation !*/
448 typedef struct asl_file_node
451 UINT32 CurrentLineNumber;
452 YY_BUFFER_STATE State;
454 struct asl_file_node *Next;
458 ASL_FILE_NODE *InputStack = NULL;
461 /*******************************************************************************
463 * FUNCTION: AslPopInputFileStack
467 * RETURN: 0 if a node was popped, -1 otherwise
469 * DESCRIPTION: Pop the top of the input file stack and point the parser to
470 * the saved parse buffer contained in the fnode. Also, set the
471 * global line counters to the saved values. This function is
472 * called when an include file reaches EOF.
474 ******************************************************************************/
477 AslPopInputFileStack (
480 ASL_FILE_NODE *Fnode;
481 FILE *InputFile = NULL;
485 DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
493 /* Close the current include file */
497 /* Update the top-of-stack */
499 InputStack = Fnode->Next;
500 InputFile = Fnode->File;
502 /* Reset global line counter and filename */
504 Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
505 Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
507 /* Point the parser to the popped file */
509 yy_delete_buffer (YY_CURRENT_BUFFER);
510 yy_switch_to_buffer (Fnode->State);
512 /* All done with this node */
519 /*******************************************************************************
521 * FUNCTION: AslPushInputFileStack
523 * PARAMETERS: InputFile - Open file pointer
524 * Filename - Name of the file
528 * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
529 * to this file. Called when an include file is successfully
532 ******************************************************************************/
535 AslPushInputFileStack (
539 ASL_FILE_NODE *Fnode;
540 YY_BUFFER_STATE State;
543 /* Save the current state in an Fnode */
545 Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
548 Fnode->Next = InputStack;
549 Fnode->State = YY_CURRENT_BUFFER;
550 Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
551 Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
553 /* Push it on the stack */
557 /* Point the parser to this file */
559 State = yy_create_buffer (InputFile, YY_BUF_SIZE);
560 yy_switch_to_buffer (State);
562 DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
564 /* Reset the global line count and filename */
566 Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
567 Gbl_CurrentLineNumber = 1;
572 /*******************************************************************************
574 * FUNCTION: ResetCurrentLineBuffer
580 * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
582 ******************************************************************************/
585 ResetCurrentLineBuffer (
589 if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
591 FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
592 Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
595 Gbl_CurrentLineOffset += Gbl_CurrentColumn;
596 Gbl_CurrentColumn = 0;
598 Gbl_CurrentLineNumber++;
599 Gbl_LogicalLineNumber++;
600 Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
604 /*******************************************************************************
606 * FUNCTION: InsertLineBuffer
608 * PARAMETERS: SourceChar - One char from the input ASL source file
612 * DESCRIPTION: Put one character of the source file into the temp line buffer
614 ******************************************************************************/
616 #define ASL_SPACES_PER_TAB 4
626 if (SourceChar == EOF)
631 Gbl_InputByteCount++;
633 /* Handle tabs. Convert to spaces */
635 if (SourceChar == '\t')
638 Count = ASL_SPACES_PER_TAB -
639 (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
643 for (i = 0; i < Count; i++)
647 /* Insert the character into the line buffer */
649 *Gbl_LineBufPtr = (UINT8) SourceChar;
652 if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1)))
656 * Warning if we have split a long source line.
657 * <Probably overkill>
659 sprintf (MsgBuffer, "Max %u", ASL_LINE_BUFFER_SIZE);
660 AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
661 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
662 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
663 Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
666 ResetCurrentLineBuffer ();
668 else if (SourceChar == '\n')
672 ResetCurrentLineBuffer ();
678 /*******************************************************************************
682 * PARAMETERS: yytext - Contains the matched keyword.
683 * Type - Keyword/Character type:
684 * 0 = anything except a keyword
685 * 1 = pseudo-keywords
686 * 2 = non-executable ASL keywords
687 * 3 = executable ASL keywords
691 * DESCRIPTION: Count keywords and put them into the line buffer
693 ******************************************************************************/
711 TotalExecutableOpcodes++;
715 for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
717 InsertLineBuffer (yytext[i]);
723 /*******************************************************************************
731 * DESCRIPTION: Process a standard comment.
733 ******************************************************************************/
742 InsertLineBuffer ('/');
743 InsertLineBuffer ('*');
747 /* Eat chars until end-of-comment */
749 while ((c = (char) input()) != '*' && c != EOF)
751 InsertLineBuffer (c);
761 * Check for nested comment -- can help catch cases where a previous
762 * comment was accidently left unterminated
764 if ((c1 == '/') && (c == '*'))
766 AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
767 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
768 Gbl_InputByteCount, Gbl_CurrentColumn,
769 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
772 /* Comment is closed only if the NEXT character is a slash */
774 InsertLineBuffer (c);
776 if ((c1 = (char) input()) != '/' && c1 != EOF)
787 InsertLineBuffer (c1);
793 * Premature End-Of-File
795 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
796 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
797 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
798 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
803 /*******************************************************************************
811 * DESCRIPTION: Process a new "//" comment.
813 ******************************************************************************/
821 InsertLineBuffer ('/');
822 InsertLineBuffer ('/');
824 while ((c = (char) input()) != '\n' && c != EOF)
826 InsertLineBuffer (c);
831 /* End of file is OK, change to newline. Let parser detect EOF later */
836 InsertLineBuffer (c);
841 /*******************************************************************************
849 * DESCRIPTION: Process a string literal (surrounded by quotes)
851 ******************************************************************************/
853 #define ASL_NORMAL_CHAR 0
854 #define ASL_ESCAPE_SEQUENCE 1
855 #define ASL_OCTAL_CONSTANT 2
856 #define ASL_HEX_CONSTANT 3
861 char *StringBuffer = MsgBuffer;
862 char *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
865 UINT32 State = ASL_NORMAL_CHAR;
868 char ConvertBuffer[4];
872 * Eat chars until end-of-literal.
873 * NOTE: Put back the original surrounding quotes into the
874 * source line buffer.
876 InsertLineBuffer ('\"');
877 while ((StringChar = (char) input()) != EOF)
879 InsertLineBuffer (StringChar);
885 case ASL_NORMAL_CHAR:
891 * Special handling for backslash-escape sequence. We will
892 * toss the backslash and translate the escape char(s).
894 State = ASL_ESCAPE_SEQUENCE;
899 /* String terminator */
901 goto CompletedString;
906 case ASL_ESCAPE_SEQUENCE:
908 State = ASL_NORMAL_CHAR;
912 StringChar = 0x07; /* BELL */
916 StringChar = 0x08; /* BACKSPACE */
920 StringChar = 0x0C; /* FORMFEED */
924 StringChar = 0x0A; /* LINEFEED */
928 StringChar = 0x0D; /* CARRIAGE RETURN*/
932 StringChar = 0x09; /* HORIZONTAL TAB */
936 StringChar = 0x0B; /* VERTICAL TAB */
940 State = ASL_HEX_CONSTANT;
944 case '\'': /* Single Quote */
945 case '\"': /* Double Quote */
946 case '\\': /* Backslash */
951 /* Check for an octal digit (0-7) */
953 if (ACPI_IS_OCTAL_DIGIT (StringChar))
955 State = ASL_OCTAL_CONSTANT;
956 ConvertBuffer[0] = StringChar;
961 /* Unknown escape sequence issue warning, but use the character */
963 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
964 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
965 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
966 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
972 case ASL_OCTAL_CONSTANT:
974 /* Up to three octal digits allowed */
976 if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
980 * Reached end of the constant. Convert the assembled ASCII
981 * string and resume processing of the next character
983 ConvertBuffer[i] = 0;
984 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
986 /* Check for NULL or non-ascii character (ignore if so) */
988 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
990 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
991 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
992 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
993 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
997 *StringBuffer = (char) Digit;
999 if (StringBuffer >= EndBuffer)
1001 goto BufferOverflow;
1005 State = ASL_NORMAL_CHAR;
1010 /* Append another digit of the constant */
1012 ConvertBuffer[i] = StringChar;
1017 case ASL_HEX_CONSTANT:
1019 /* Up to two hex digits allowed */
1021 if (!ACPI_IS_XDIGIT (StringChar) ||
1025 * Reached end of the constant. Convert the assembled ASCII
1026 * string and resume processing of the next character
1028 ConvertBuffer[i] = 0;
1029 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
1031 /* Check for NULL or non-ascii character (ignore if so) */
1033 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
1035 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
1036 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1037 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1038 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1042 *StringBuffer = (char) Digit;
1044 if (StringBuffer >= EndBuffer)
1046 goto BufferOverflow;
1050 State = ASL_NORMAL_CHAR;
1055 /* Append another digit of the constant */
1057 ConvertBuffer[i] = StringChar;
1062 /* Save the finished character */
1064 *StringBuffer = StringChar;
1066 if (StringBuffer >= EndBuffer)
1068 goto BufferOverflow;
1073 * Premature End-Of-File
1075 AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
1076 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1077 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1078 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1084 * Null terminate the input string and copy string to a new buffer
1088 CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
1091 AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
1092 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1093 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1094 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
1098 ACPI_STRCPY (CleanString, MsgBuffer);
1099 AslCompilerlval.s = CleanString;
1105 /* Literal was too long */
1107 AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
1108 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
1109 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
1110 Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");