Subversion Repositories Kolibri OS

Rev

Rev 1498 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. %{
  3. /******************************************************************************
  4.  *
  5.  * Module Name: aslcompiler.l - Flex input file
  6.  *
  7.  *****************************************************************************/
  8.  
  9. /******************************************************************************
  10.  *
  11.  * 1. Copyright Notice
  12.  *
  13.  * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  14.  * All rights reserved.
  15.  *
  16.  * 2. License
  17.  *
  18.  * 2.1. This is your license from Intel Corp. under its intellectual property
  19.  * rights.  You may have additional license terms from the party that provided
  20.  * you this software, covering your right to use that party's intellectual
  21.  * property rights.
  22.  *
  23.  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  24.  * copy of the source code appearing in this file ("Covered Code") an
  25.  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  26.  * base code distributed originally by Intel ("Original Intel Code") to copy,
  27.  * make derivatives, distribute, use and display any portion of the Covered
  28.  * Code in any form, with the right to sublicense such rights; and
  29.  *
  30.  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  31.  * license (with the right to sublicense), under only those claims of Intel
  32.  * patents that are infringed by the Original Intel Code, to make, use, sell,
  33.  * offer to sell, and import the Covered Code and derivative works thereof
  34.  * solely to the minimum extent necessary to exercise the above copyright
  35.  * license, and in no event shall the patent license extend to any additions
  36.  * to or modifications of the Original Intel Code.  No other license or right
  37.  * is granted directly or by implication, estoppel or otherwise;
  38.  *
  39.  * The above copyright and patent license is granted only if the following
  40.  * conditions are met:
  41.  *
  42.  * 3. Conditions
  43.  *
  44.  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  45.  * Redistribution of source code of any substantial portion of the Covered
  46.  * Code or modification with rights to further distribute source must include
  47.  * the above Copyright Notice, the above License, this list of Conditions,
  48.  * and the following Disclaimer and Export Compliance provision.  In addition,
  49.  * Licensee must cause all Covered Code to which Licensee contributes to
  50.  * contain a file documenting the changes Licensee made to create that Covered
  51.  * Code and the date of any change.  Licensee must include in that file the
  52.  * documentation of any changes made by any predecessor Licensee.  Licensee
  53.  * must include a prominent statement that the modification is derived,
  54.  * directly or indirectly, from Original Intel Code.
  55.  *
  56.  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  57.  * Redistribution of source code of any substantial portion of the Covered
  58.  * Code or modification without rights to further distribute source must
  59.  * include the following Disclaimer and Export Compliance provision in the
  60.  * documentation and/or other materials provided with distribution.  In
  61.  * addition, Licensee may not authorize further sublicense of source of any
  62.  * portion of the Covered Code, and must include terms to the effect that the
  63.  * license from Licensee to its licensee is limited to the intellectual
  64.  * property embodied in the software Licensee provides to its licensee, and
  65.  * not to intellectual property embodied in modifications its licensee may
  66.  * make.
  67.  *
  68.  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  69.  * substantial portion of the Covered Code or modification must reproduce the
  70.  * above Copyright Notice, and the following Disclaimer and Export Compliance
  71.  * provision in the documentation and/or other materials provided with the
  72.  * distribution.
  73.  *
  74.  * 3.4. Intel retains all right, title, and interest in and to the Original
  75.  * Intel Code.
  76.  *
  77.  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  78.  * Intel shall be used in advertising or otherwise to promote the sale, use or
  79.  * other dealings in products derived from or relating to the Covered Code
  80.  * without prior written authorization from Intel.
  81.  *
  82.  * 4. Disclaimer and Export Compliance
  83.  *
  84.  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  85.  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  86.  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  87.  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  88.  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  89.  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  90.  * PARTICULAR PURPOSE.
  91.  *
  92.  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  93.  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  94.  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  95.  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  96.  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  97.  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  98.  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  99.  * LIMITED REMEDY.
  100.  *
  101.  * 4.3. Licensee shall not export, either directly or indirectly, any of this
  102.  * software or system incorporating such software without first obtaining any
  103.  * required license or other approval from the U. S. Department of Commerce or
  104.  * any other agency or department of the United States Government.  In the
  105.  * event Licensee exports any such software from the United States or
  106.  * re-exports any such software from a foreign destination, Licensee shall
  107.  * ensure that the distribution and export/re-export of the software is in
  108.  * compliance with all laws, regulations, orders, or other restrictions of the
  109.  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
  110.  * any of its subsidiaries will export/re-export any technical data, process,
  111.  * software, or service, directly or indirectly, to any country for which the
  112.  * United States government or any agency thereof requires an export license,
  113.  * other governmental approval, or letter of assurance, without first obtaining
  114.  * such license, approval or letter.
  115.  *
  116.  *****************************************************************************/
  117.  
  118. #include "aslcompiler.h"
  119. #include "aslcompiler.y.h"
  120.  
  121. #include <stdlib.h>
  122. #include <string.h>
  123. YYSTYPE AslCompilerlval;
  124.  
  125. /*
  126.  * Generation:  Use the following command line:
  127.  *
  128.  * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath)
  129.  *
  130.  * -i: Scanner must be case-insensitive
  131.  */
  132.  
  133. #define _COMPONENT          ACPI_COMPILER
  134.         ACPI_MODULE_NAME    ("aslscan")
  135. char
  136. comment (void);
  137. char
  138. comment2 (void);
  139. void
  140. count (int type);
  141. char
  142. literal (void);
  143. void
  144. copy (void);
  145.  
  146. /*! [Begin] no source code translation */
  147.  
  148. %}
  149.  
  150.  
  151. LeadNameChar                [A-Za-z_]
  152. DigitChar                   [0-9]
  153. HexDigitChar                [A-Fa-f0-9]
  154. RootChar                    [\\]
  155. Nothing                     []
  156.  
  157. NameChar                    [A-Za-z_0-9]
  158. NameSeg1                    {LeadNameChar}{NameChar}
  159. NameSeg2                    {LeadNameChar}{NameChar}{NameChar}
  160. NameSeg3                    {LeadNameChar}{NameChar}{NameChar}{NameChar}
  161. NameSeg                     {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3}
  162.  
  163. NameString                  {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath}
  164. NamePath                    {NonEmptyNamePath}?
  165. NonEmptyNamePath            {NameSeg}{NamePathTail}*
  166. NamePathTail                [.]{NameSeg}
  167.  
  168. %%
  169.  
  170. [ ]                         { count (0); }
  171. [\n]                        { count (0); } /* Handle files with both LF and CR/LF */
  172. [\r]                        { count (0); } /* termination on both Unix and Windows */
  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.  
  182. 0[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. "IPMI"                      { count (0); return (PARSEOP_REGIONSPACE_IPMI); }
  390.  
  391. "FFixedHW"                  { count (0); return (PARSEOP_ADDRESSSPACE_FFIXEDHW); }
  392.  
  393. "SMBQuick"                  { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); }
  394. "SMBSendReceive"            { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); }
  395. "SMBByte"                   { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); }
  396. "SMBWord"                   { count (0); return (PARSEOP_ACCESSATTRIB_WORD); }
  397. "SMBBlock"                  { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); }
  398. "SMBProcessCall"            { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); }
  399. "SMBBlockProcessCall"       { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); }
  400.  
  401. "MTR"                       { count (0); return (PARSEOP_MATCHTYPE_MTR); }
  402. "MEQ"                       { count (0); return (PARSEOP_MATCHTYPE_MEQ); }
  403. "MLE"                       { count (0); return (PARSEOP_MATCHTYPE_MLE); }
  404. "MLT"                       { count (0); return (PARSEOP_MATCHTYPE_MLT); }
  405. "MGE"                       { count (0); return (PARSEOP_MATCHTYPE_MGE); }
  406. "MGT"                       { count (0); return (PARSEOP_MATCHTYPE_MGT); }
  407.  
  408. "Compatibility"             { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); }
  409. "TypeA"                     { count (0); return (PARSEOP_DMATYPE_A); }
  410. "TypeB"                     { count (0); return (PARSEOP_DMATYPE_B); }
  411. "TypeF"                     { count (0); return (PARSEOP_DMATYPE_F); }
  412.  
  413. "BusMaster"                 { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); }
  414. "NotBusMaster"              { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); }
  415.  
  416. "Transfer8"                 { count (0); return (PARSEOP_XFERTYPE_8); }
  417. "Transfer8_16"              { count (0); return (PARSEOP_XFERTYPE_8_16); }
  418. "Transfer16"                { count (0); return (PARSEOP_XFERTYPE_16); }
  419.  
  420. "ResourceConsumer"          { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); }
  421. "ResourceProducer"          { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); }
  422.  
  423. "MinFixed"                  { count (0); return (PARSEOP_MINTYPE_FIXED); }
  424. "MinNotFixed"               { count (0); return (PARSEOP_MINTYPE_NOTFIXED); }
  425.  
  426. "MaxFixed"                  { count (0); return (PARSEOP_MAXTYPE_FIXED); }
  427. "MaxNotFixed"               { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); }
  428.  
  429. "PosDecode"                 { count (0); return (PARSEOP_DECODETYPE_POS); }
  430. "SubDecode"                 { count (0); return (PARSEOP_DECODETYPE_SUB); }
  431.  
  432. "ISAOnlyRanges"             { count (0); return (PARSEOP_RANGETYPE_ISAONLY); }
  433. "NonISAOnlyRanges"          { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); }
  434. "EntireRange"               { count (0); return (PARSEOP_RANGETYPE_ENTIRE); }
  435.  
  436. "Cacheable"                 { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); }
  437. "WriteCombining"            { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); }
  438. "Prefetchable"              { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); }
  439. "NonCacheable"              { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); }
  440.  
  441. "ReadWrite"                 { count (0); return (PARSEOP_READWRITETYPE_BOTH); }
  442. "ReadOnly"                  { count (0); return (PARSEOP_READWRITETYPE_READONLY); }
  443.  
  444. "Edge"                      { count (0); return (PARSEOP_INTTYPE_EDGE); }
  445. "Level"                     { count (0); return (PARSEOP_INTTYPE_LEVEL); }
  446.  
  447. "ActiveHigh"                { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); }
  448. "ActiveLow"                 { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); }
  449.  
  450. "Shared"                    { count (0); return (PARSEOP_SHARETYPE_SHARED); }
  451. "Exclusive"                 { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); }
  452.  
  453. "Decode10"                  { count (0); return (PARSEOP_IODECODETYPE_10); }
  454. "Decode16"                  { count (0); return (PARSEOP_IODECODETYPE_16); }
  455.  
  456. "TypeTranslation"           { count (0); return (PARSEOP_TYPE_TRANSLATION); }
  457. "TypeStatic"                { count (0); return (PARSEOP_TYPE_STATIC); }
  458.  
  459. "SparseTranslation"         { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); }
  460. "DenseTranslation"          { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); }
  461.  
  462. "AddressRangeMemory"        { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); }
  463. "AddressRangeReserved"      { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); }
  464. "AddressRangeNVS"           { count (0); return (PARSEOP_ADDRESSTYPE_NVS); }
  465. "AddressRangeACPI"          { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); }
  466.  
  467. "__DATE__"                  { count (0); return (PARSEOP___DATE__); }
  468. "__FILE__"                  { count (0); return (PARSEOP___FILE__); }
  469. "__LINE__"                  { count (0); return (PARSEOP___LINE__); }
  470.  
  471. "{"                         { count (0); return('{'); }
  472. "}"                         { count (0); return('}'); }
  473. ","                         { count (0); return(','); }
  474. "("                         { count (0); return('('); }
  475. ")"                         { count (0); return(')'); }
  476.  
  477.  
  478. {NameSeg}                   { char *s;
  479.                                 count (0);
  480.                                 s=malloc (ACPI_NAME_SIZE + 1);
  481.                                 if (strcmp (AslCompilertext, "\\"))
  482.                                 {
  483.                                     strcpy (s, "____");
  484.                                     AcpiUtStrupr (AslCompilertext);
  485.                                 }
  486.                                 memcpy (s, AslCompilertext, strlen (AslCompilertext));
  487.                                 AslCompilerlval.s = s;
  488.                                 DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s);
  489.                                 return (PARSEOP_NAMESEG); }
  490.  
  491. {NameString}                { char *s;
  492.                                 count (0);
  493.                                 s=malloc (strlen (AslCompilertext)+1);
  494.                                 AcpiUtStrupr (AslCompilertext);
  495.                                 strcpy (s, AslCompilertext);
  496.                                 s[strlen (AslCompilertext)] = 0;
  497.                                 AslCompilerlval.s = s;
  498.                                 DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s);
  499.                                 return (PARSEOP_NAMESTRING); }
  500.  
  501. "*" |
  502. "/"                         { count (1);
  503.                                 AslCompilererror ("Parse error, expecting ASL keyword or name");}
  504.  
  505. .                           { count (1);
  506.                                 sprintf (MsgBuffer,
  507.                                     "Invalid character (0x%2.2X), expecting ASL keyword or name",
  508.                                     *AslCompilertext);
  509.                                 AslCompilererror (MsgBuffer);}
  510.  
  511. <<EOF>>                     { if (AslPopInputFileStack ())
  512.                                 yyterminate();
  513.                               else
  514.                                 return (PARSEOP_INCLUDE_END);};
  515.  
  516. %%
  517.  
  518. /*! [End] no source code translation !*/
  519.  
  520. typedef struct asl_file_node
  521. {
  522.     FILE                    *File;
  523.     UINT32                  CurrentLineNumber;
  524.     YY_BUFFER_STATE         State;
  525.     char                    *Filename;
  526.     struct asl_file_node    *Next;
  527.  
  528. } ASL_FILE_NODE;
  529.  
  530. ASL_FILE_NODE               *InputStack = NULL;
  531.  
  532.  
  533. /*******************************************************************************
  534.  *
  535.  * FUNCTION:    AslPopInputFileStack
  536.  *
  537.  * PARAMETERS:  None
  538.  *
  539.  * RETURN:      0 if a node was popped, -1 otherwise
  540.  *
  541.  * DESCRIPTION: Pop the top of the input file stack and point the parser to
  542.  *              the saved parse buffer contained in the fnode.  Also, set the
  543.  *              global line counters to the saved values.  This function is
  544.  *              called when an include file reaches EOF.
  545.  *
  546.  ******************************************************************************/
  547.  
  548. int
  549. AslPopInputFileStack (
  550.     void)
  551. {
  552.     ASL_FILE_NODE           *Fnode;
  553.     FILE                    *InputFile = NULL;
  554.  
  555.  
  556.     Fnode = InputStack;
  557.     DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
  558.  
  559.  
  560.     if (!Fnode)
  561.     {
  562.         return -1;
  563.     }
  564.  
  565.     /* Close the current include file */
  566.  
  567.     fclose (yyin);
  568.  
  569.     /* Update the top-of-stack */
  570.  
  571.     InputStack = Fnode->Next;
  572.     InputFile = Fnode->File;
  573.  
  574.     /* Reset global line counter and filename */
  575.  
  576.     Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
  577.     Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
  578.  
  579.     /* Point the parser to the popped file */
  580.  
  581.     yy_delete_buffer (YY_CURRENT_BUFFER);
  582.     yy_switch_to_buffer (Fnode->State);
  583.  
  584.     /* All done with this node */
  585.  
  586.     ACPI_FREE (Fnode);
  587.     return 0;
  588. }
  589.  
  590.  
  591. /*******************************************************************************
  592.  *
  593.  * FUNCTION:    AslPushInputFileStack
  594.  *
  595.  * PARAMETERS:  InputFile           - Open file pointer
  596.  *              Filename            - Name of the file
  597.  *
  598.  * RETURN:      None
  599.  *
  600.  * DESCRIPTION: Push the InputFile onto the file stack, and point the parser
  601.  *              to this file.  Called when an include file is successfully
  602.  *              opened.
  603.  *
  604.  ******************************************************************************/
  605.  
  606. void
  607. AslPushInputFileStack (
  608.     FILE                    *InputFile,
  609.     char                    *Filename)
  610. {
  611.     ASL_FILE_NODE           *Fnode;
  612.     YY_BUFFER_STATE         State;
  613.  
  614.  
  615.     /* Save the current state in an Fnode */
  616.  
  617.     Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
  618.  
  619.     Fnode->File                 = yyin;
  620.     Fnode->Next                 = InputStack;
  621.     Fnode->State                = YY_CURRENT_BUFFER;
  622.     Fnode->CurrentLineNumber    = Gbl_CurrentLineNumber;
  623.     Fnode->Filename             = Gbl_Files[ASL_FILE_INPUT].Filename;
  624.  
  625.     /* Push it on the stack */
  626.  
  627.     InputStack = Fnode;
  628.  
  629.     /* Point the parser to this file */
  630.  
  631.     State = yy_create_buffer (InputFile, YY_BUF_SIZE);
  632.     yy_switch_to_buffer (State);
  633.  
  634.     DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
  635.  
  636.     /* Reset the global line count and filename */
  637.  
  638.     Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
  639.     Gbl_CurrentLineNumber = 1;
  640.     yyin = InputFile;
  641. }
  642.  
  643.  
  644. /*******************************************************************************
  645.  *
  646.  * FUNCTION:    ResetCurrentLineBuffer
  647.  *
  648.  * PARAMETERS:  None
  649.  *
  650.  * RETURN:      None
  651.  *
  652.  * DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
  653.  *
  654.  ******************************************************************************/
  655.  
  656. void
  657. ResetCurrentLineBuffer (
  658.     void)
  659. {
  660.  
  661.     if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
  662.     {
  663.         FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
  664.             Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
  665.     }
  666.  
  667.     Gbl_CurrentLineOffset += Gbl_CurrentColumn;
  668.     Gbl_CurrentColumn = 0;
  669.  
  670.     Gbl_CurrentLineNumber++;
  671.     Gbl_LogicalLineNumber++;
  672.     Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
  673. }
  674.  
  675.  
  676. /*******************************************************************************
  677.  *
  678.  * FUNCTION:    InsertLineBuffer
  679.  *
  680.  * PARAMETERS:  SourceChar      - One char from the input ASL source file
  681.  *
  682.  * RETURN:      None
  683.  *
  684.  * DESCRIPTION: Put one character of the source file into the temp line buffer
  685.  *
  686.  ******************************************************************************/
  687.  
  688. #define ASL_SPACES_PER_TAB  4
  689.  
  690. void
  691. InsertLineBuffer (
  692.     int                     SourceChar)
  693. {
  694.     UINT32                  i;
  695.     UINT32                  Count = 1;
  696.  
  697.  
  698.     if (SourceChar == EOF)
  699.     {
  700.         return;
  701.     }
  702.  
  703.     Gbl_InputByteCount++;
  704.  
  705.     /* Handle tabs.  Convert to spaces */
  706.  
  707.     if (SourceChar == '\t')
  708.     {
  709.         SourceChar = ' ';
  710.         Count = ASL_SPACES_PER_TAB -
  711.                     (Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
  712.     }
  713.  
  714.  
  715.     for (i = 0; i < Count; i++)
  716.     {
  717.         Gbl_CurrentColumn++;
  718.  
  719.         /* Insert the character into the line buffer */
  720.  
  721.         *Gbl_LineBufPtr = (UINT8) SourceChar;
  722.         Gbl_LineBufPtr++;
  723.  
  724.         if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1)))
  725.         {
  726. #if 0
  727.             /*
  728.              * Warning if we have split a long source line.
  729.              * <Probably overkill>
  730.              */
  731.             sprintf (MsgBuffer, "Max %u", ASL_LINE_BUFFER_SIZE);
  732.             AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
  733.                             Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  734.                             Gbl_CurrentLineOffset, Gbl_CurrentColumn,
  735.                             Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
  736. #endif
  737.  
  738.             ResetCurrentLineBuffer ();
  739.         }
  740.         else if (SourceChar == '\n')
  741.         {
  742.             /* End of line */
  743.  
  744.             ResetCurrentLineBuffer ();
  745.         }
  746.     }
  747. }
  748.  
  749.  
  750. /*******************************************************************************
  751.  *
  752.  * FUNCTION:    count
  753.  *
  754.  * PARAMETERS:  yytext      - Contains the matched keyword.
  755.  *              Type        - Keyword/Character type:
  756.  *                             0 = anything except a keyword
  757.  *                             1 = pseudo-keywords
  758.  *                             2 = non-executable ASL keywords
  759.  *                             3 = executable ASL keywords
  760.  *
  761.  * RETURN:      None
  762.  *
  763.  * DESCRIPTION: Count keywords and put them into the line buffer
  764.  *
  765.  ******************************************************************************/
  766.  
  767. void
  768. count (
  769.     int                 Type)
  770. {
  771.     int                 i;
  772.  
  773.  
  774.     switch (Type)
  775.     {
  776.     case 2:
  777.         TotalKeywords++;
  778.         TotalNamedObjects++;
  779.         break;
  780.  
  781.     case 3:
  782.         TotalKeywords++;
  783.         TotalExecutableOpcodes++;
  784.         break;
  785.     }
  786.  
  787.     for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
  788.     {
  789.         InsertLineBuffer (yytext[i]);
  790.         *Gbl_LineBufPtr = 0;
  791.     }
  792. }
  793.  
  794.  
  795. /*******************************************************************************
  796.  *
  797.  * FUNCTION:    comment
  798.  *
  799.  * PARAMETERS:  none
  800.  *
  801.  * RETURN:      none
  802.  *
  803.  * DESCRIPTION: Process a standard comment.
  804.  *
  805.  ******************************************************************************/
  806.  
  807. char
  808. comment (void)
  809. {
  810.     char                c;
  811.     char                c1 = 0;
  812.  
  813.  
  814.     InsertLineBuffer ('/');
  815.     InsertLineBuffer ('*');
  816.  
  817. loop:
  818.  
  819.     /* Eat chars until end-of-comment */
  820.  
  821.     while ((c = (char) input()) != '*' && c != EOF)
  822.     {
  823.         InsertLineBuffer (c);
  824.         c1 = c;
  825.     }
  826.  
  827.     if (c == EOF)
  828.     {
  829.         goto EarlyEOF;
  830.     }
  831.  
  832.     /*
  833.      * Check for nested comment -- can help catch cases where a previous
  834.      * comment was accidently left unterminated
  835.      */
  836.     if ((c1 == '/') && (c == '*'))
  837.     {
  838.         AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
  839.                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  840.                         Gbl_InputByteCount, Gbl_CurrentColumn,
  841.                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
  842.     }
  843.  
  844.     /* Comment is closed only if the NEXT character is a slash */
  845.  
  846.     InsertLineBuffer (c);
  847.  
  848.     if ((c1 = (char) input()) != '/' && c1 != EOF)
  849.     {
  850.         unput(c1);
  851.         goto loop;
  852.     }
  853.  
  854.     if (c1 == EOF)
  855.     {
  856.         goto EarlyEOF;
  857.     }
  858.  
  859.     InsertLineBuffer (c1);
  860.     return TRUE;
  861.  
  862.  
  863. EarlyEOF:
  864.     /*
  865.      * Premature End-Of-File
  866.      */
  867.     AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
  868.                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  869.                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
  870.                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
  871.     return (FALSE);
  872. }
  873.  
  874.  
  875. /*******************************************************************************
  876.  *
  877.  * FUNCTION:    comment
  878.  *
  879.  * PARAMETERS:  none
  880.  *
  881.  * RETURN:      none
  882.  *
  883.  * DESCRIPTION: Process a new "//" comment.
  884.  *
  885.  ******************************************************************************/
  886.  
  887. char
  888. comment2 (void)
  889. {
  890.     char                c;
  891.  
  892.  
  893.     InsertLineBuffer ('/');
  894.     InsertLineBuffer ('/');
  895.  
  896.     while ((c = (char) input()) != '\n' && c != EOF)
  897.     {
  898.         InsertLineBuffer (c);
  899.     }
  900.  
  901.     if (c == EOF)
  902.     {
  903.         /* End of file is OK, change to newline. Let parser detect EOF later */
  904.  
  905.         c = '\n';
  906.     }
  907.  
  908.     InsertLineBuffer (c);
  909.     return (TRUE);
  910. }
  911.  
  912.  
  913. /*******************************************************************************
  914.  *
  915.  * FUNCTION:    literal
  916.  *
  917.  * PARAMETERS:  none
  918.  *
  919.  * RETURN:      none
  920.  *
  921.  * DESCRIPTION: Process a string literal (surrounded by quotes)
  922.  *
  923.  ******************************************************************************/
  924.  
  925. #define ASL_NORMAL_CHAR         0
  926. #define ASL_ESCAPE_SEQUENCE     1
  927. #define ASL_OCTAL_CONSTANT      2
  928. #define ASL_HEX_CONSTANT        3
  929.  
  930. char
  931. literal (void)
  932. {
  933.     char                *StringBuffer = MsgBuffer;
  934.     char                *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
  935.     char                *CleanString;
  936.     char                StringChar;
  937.     UINT32              State = ASL_NORMAL_CHAR;
  938.     UINT32              i = 0;
  939.     UINT8               Digit;
  940.     char                ConvertBuffer[4];
  941.  
  942.  
  943.     /*
  944.      * Eat chars until end-of-literal.
  945.      * NOTE:  Put back the original surrounding quotes into the
  946.      * source line buffer.
  947.      */
  948.     InsertLineBuffer ('\"');
  949.     while ((StringChar = (char) input()) != EOF)
  950.     {
  951.         InsertLineBuffer (StringChar);
  952.  
  953. DoCharacter:
  954.  
  955.         switch (State)
  956.         {
  957.         case ASL_NORMAL_CHAR:
  958.  
  959.             switch (StringChar)
  960.             {
  961.             case '\\':
  962.                 /*
  963.                  * Special handling for backslash-escape sequence.  We will
  964.                  * toss the backslash and translate the escape char(s).
  965.                  */
  966.                 State = ASL_ESCAPE_SEQUENCE;
  967.                 continue;
  968.  
  969.             case '\"':
  970.  
  971.                 /* String terminator */
  972.  
  973.                 goto CompletedString;
  974.             }
  975.             break;
  976.  
  977.  
  978.         case ASL_ESCAPE_SEQUENCE:
  979.  
  980.             State = ASL_NORMAL_CHAR;
  981.             switch (StringChar)
  982.             {
  983.             case 'a':
  984.                 StringChar = 0x07;      /* BELL */
  985.                 break;
  986.  
  987.             case 'b':
  988.                 StringChar = 0x08;      /* BACKSPACE */
  989.                 break;
  990.  
  991.             case 'f':
  992.                 StringChar = 0x0C;      /* FORMFEED */
  993.                 break;
  994.  
  995.             case 'n':
  996.                 StringChar = 0x0A;      /* LINEFEED */
  997.                 break;
  998.  
  999.             case 'r':
  1000.                 StringChar = 0x0D;      /* CARRIAGE RETURN*/
  1001.                 break;
  1002.  
  1003.             case 't':
  1004.                 StringChar = 0x09;      /* HORIZONTAL TAB */
  1005.                 break;
  1006.  
  1007.             case 'v':
  1008.                 StringChar = 0x0B;      /* VERTICAL TAB */
  1009.                 break;
  1010.  
  1011.             case 'x':
  1012.                 State = ASL_HEX_CONSTANT;
  1013.                 i = 0;
  1014.                 continue;
  1015.  
  1016.             case '\'':                  /* Single Quote */
  1017.             case '\"':                  /* Double Quote */
  1018.             case '\\':                  /* Backslash */
  1019.                 break;
  1020.  
  1021.             default:
  1022.  
  1023.                 /* Check for an octal digit (0-7) */
  1024.  
  1025.                 if (ACPI_IS_OCTAL_DIGIT (StringChar))
  1026.                 {
  1027.                     State = ASL_OCTAL_CONSTANT;
  1028.                     ConvertBuffer[0] = StringChar;
  1029.                     i = 1;
  1030.                     continue;
  1031.                 }
  1032.  
  1033.                 /* Unknown escape sequence issue warning, but use the character */
  1034.  
  1035.                 AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
  1036.                                 Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  1037.                                 Gbl_CurrentLineOffset, Gbl_CurrentColumn,
  1038.                                 Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
  1039.                                 break;
  1040.             }
  1041.             break;
  1042.  
  1043.  
  1044.         case ASL_OCTAL_CONSTANT:
  1045.  
  1046.             /* Up to three octal digits allowed */
  1047.  
  1048.             if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
  1049.                 (i > 2))
  1050.             {
  1051.                 /*
  1052.                  * Reached end of the constant.  Convert the assembled ASCII
  1053.                  * string and resume processing of the next character
  1054.                  */
  1055.                 ConvertBuffer[i] = 0;
  1056.                 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
  1057.  
  1058.                 /* Check for NULL or non-ascii character (ignore if so) */
  1059.  
  1060.                 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
  1061.                 {
  1062.                     AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
  1063.                                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  1064.                                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
  1065.                                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
  1066.                 }
  1067.                 else
  1068.                 {
  1069.                     *StringBuffer = (char) Digit;
  1070.                     StringBuffer++;
  1071.                     if (StringBuffer >= EndBuffer)
  1072.                     {
  1073.                         goto BufferOverflow;
  1074.                     }
  1075.                 }
  1076.  
  1077.                 State = ASL_NORMAL_CHAR;
  1078.                 goto DoCharacter;
  1079.                 break;
  1080.             }
  1081.  
  1082.             /* Append another digit of the constant */
  1083.  
  1084.             ConvertBuffer[i] = StringChar;
  1085.             i++;
  1086.             continue;
  1087.  
  1088.  
  1089.         case ASL_HEX_CONSTANT:
  1090.  
  1091.             /* Up to two hex digits allowed */
  1092.  
  1093.             if (!ACPI_IS_XDIGIT (StringChar) ||
  1094.                 (i > 1))
  1095.             {
  1096.                 /*
  1097.                  * Reached end of the constant.  Convert the assembled ASCII
  1098.                  * string and resume processing of the next character
  1099.                  */
  1100.                 ConvertBuffer[i] = 0;
  1101.                 Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
  1102.  
  1103.                 /* Check for NULL or non-ascii character (ignore if so) */
  1104.  
  1105.                 if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
  1106.                 {
  1107.                     AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
  1108.                                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  1109.                                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
  1110.                                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
  1111.                 }
  1112.                 else
  1113.                 {
  1114.                     *StringBuffer = (char) Digit;
  1115.                     StringBuffer++;
  1116.                     if (StringBuffer >= EndBuffer)
  1117.                     {
  1118.                         goto BufferOverflow;
  1119.                     }
  1120.                 }
  1121.  
  1122.                 State = ASL_NORMAL_CHAR;
  1123.                 goto DoCharacter;
  1124.                 break;
  1125.             }
  1126.  
  1127.             /* Append another digit of the constant */
  1128.  
  1129.             ConvertBuffer[i] = StringChar;
  1130.             i++;
  1131.             continue;
  1132.         }
  1133.  
  1134.         /* Save the finished character */
  1135.  
  1136.         *StringBuffer = StringChar;
  1137.         StringBuffer++;
  1138.         if (StringBuffer >= EndBuffer)
  1139.         {
  1140.             goto BufferOverflow;
  1141.         }
  1142.     }
  1143.  
  1144.     /*
  1145.      * Premature End-Of-File
  1146.      */
  1147.     AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
  1148.                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  1149.                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
  1150.                     Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
  1151.     return (FALSE);
  1152.  
  1153.  
  1154. CompletedString:
  1155.     /*
  1156.      * Null terminate the input string and copy string to a new buffer
  1157.      */
  1158.     *StringBuffer = 0;
  1159.  
  1160.     CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
  1161.     if (!CleanString)
  1162.     {
  1163.         AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
  1164.                         Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  1165.                         Gbl_CurrentLineOffset, Gbl_CurrentColumn,
  1166.                         Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
  1167.         return (FALSE);
  1168.     }
  1169.  
  1170.     ACPI_STRCPY (CleanString, MsgBuffer);
  1171.     AslCompilerlval.s = CleanString;
  1172.     return (TRUE);
  1173.  
  1174.  
  1175. BufferOverflow:
  1176.  
  1177.     /* Literal was too long */
  1178.  
  1179.     AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
  1180.                     Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
  1181.                     Gbl_CurrentLineOffset, Gbl_CurrentColumn,
  1182.                     Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");
  1183.     return (FALSE);
  1184. }
  1185.  
  1186.  
  1187.