1118611Snjl%{ 2118611Snjl/****************************************************************************** 3118611Snjl * 4228110Sjkim * Module Name: aslcompiler.l - Flex/lex input file 5118611Snjl * 6118611Snjl *****************************************************************************/ 7118611Snjl 8316303Sjkim/****************************************************************************** 9316303Sjkim * 10316303Sjkim * 1. Copyright Notice 11316303Sjkim * 12316303Sjkim * Some or all of this work - Copyright (c) 1999 - 2017, Intel Corp. 13118611Snjl * All rights reserved. 14118611Snjl * 15316303Sjkim * 2. License 16316303Sjkim * 17316303Sjkim * 2.1. This is your license from Intel Corp. under its intellectual property 18316303Sjkim * rights. You may have additional license terms from the party that provided 19316303Sjkim * you this software, covering your right to use that party's intellectual 20316303Sjkim * property rights. 21316303Sjkim * 22316303Sjkim * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a 23316303Sjkim * copy of the source code appearing in this file ("Covered Code") an 24316303Sjkim * irrevocable, perpetual, worldwide license under Intel's copyrights in the 25316303Sjkim * base code distributed originally by Intel ("Original Intel Code") to copy, 26316303Sjkim * make derivatives, distribute, use and display any portion of the Covered 27316303Sjkim * Code in any form, with the right to sublicense such rights; and 28316303Sjkim * 29316303Sjkim * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent 30316303Sjkim * license (with the right to sublicense), under only those claims of Intel 31316303Sjkim * patents that are infringed by the Original Intel Code, to make, use, sell, 32316303Sjkim * offer to sell, and import the Covered Code and derivative works thereof 33316303Sjkim * solely to the minimum extent necessary to exercise the above copyright 34316303Sjkim * license, and in no event shall the patent license extend to any additions 35316303Sjkim * to or modifications of the Original Intel Code. No other license or right 36316303Sjkim * is granted directly or by implication, estoppel or otherwise; 37316303Sjkim * 38316303Sjkim * The above copyright and patent license is granted only if the following 39316303Sjkim * conditions are met: 40316303Sjkim * 41316303Sjkim * 3. Conditions 42316303Sjkim * 43316303Sjkim * 3.1. Redistribution of Source with Rights to Further Distribute Source. 44316303Sjkim * Redistribution of source code of any substantial portion of the Covered 45316303Sjkim * Code or modification with rights to further distribute source must include 46316303Sjkim * the above Copyright Notice, the above License, this list of Conditions, 47316303Sjkim * and the following Disclaimer and Export Compliance provision. In addition, 48316303Sjkim * Licensee must cause all Covered Code to which Licensee contributes to 49316303Sjkim * contain a file documenting the changes Licensee made to create that Covered 50316303Sjkim * Code and the date of any change. Licensee must include in that file the 51316303Sjkim * documentation of any changes made by any predecessor Licensee. Licensee 52316303Sjkim * must include a prominent statement that the modification is derived, 53316303Sjkim * directly or indirectly, from Original Intel Code. 54316303Sjkim * 55316303Sjkim * 3.2. Redistribution of Source with no Rights to Further Distribute Source. 56316303Sjkim * Redistribution of source code of any substantial portion of the Covered 57316303Sjkim * Code or modification without rights to further distribute source must 58316303Sjkim * include the following Disclaimer and Export Compliance provision in the 59316303Sjkim * documentation and/or other materials provided with distribution. In 60316303Sjkim * addition, Licensee may not authorize further sublicense of source of any 61316303Sjkim * portion of the Covered Code, and must include terms to the effect that the 62316303Sjkim * license from Licensee to its licensee is limited to the intellectual 63316303Sjkim * property embodied in the software Licensee provides to its licensee, and 64316303Sjkim * not to intellectual property embodied in modifications its licensee may 65316303Sjkim * make. 66316303Sjkim * 67316303Sjkim * 3.3. Redistribution of Executable. Redistribution in executable form of any 68316303Sjkim * substantial portion of the Covered Code or modification must reproduce the 69316303Sjkim * above Copyright Notice, and the following Disclaimer and Export Compliance 70316303Sjkim * provision in the documentation and/or other materials provided with the 71316303Sjkim * distribution. 72316303Sjkim * 73316303Sjkim * 3.4. Intel retains all right, title, and interest in and to the Original 74316303Sjkim * Intel Code. 75316303Sjkim * 76316303Sjkim * 3.5. Neither the name Intel nor any other trademark owned or controlled by 77316303Sjkim * Intel shall be used in advertising or otherwise to promote the sale, use or 78316303Sjkim * other dealings in products derived from or relating to the Covered Code 79316303Sjkim * without prior written authorization from Intel. 80316303Sjkim * 81316303Sjkim * 4. Disclaimer and Export Compliance 82316303Sjkim * 83316303Sjkim * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED 84316303Sjkim * HERE. ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE 85316303Sjkim * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT, ASSISTANCE, 86316303Sjkim * INSTALLATION, TRAINING OR OTHER SERVICES. INTEL WILL NOT PROVIDE ANY 87316303Sjkim * UPDATES, ENHANCEMENTS OR EXTENSIONS. INTEL SPECIFICALLY DISCLAIMS ANY 88316303Sjkim * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A 89316303Sjkim * PARTICULAR PURPOSE. 90316303Sjkim * 91316303Sjkim * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES 92316303Sjkim * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR 93316303Sjkim * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT, 94316303Sjkim * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY 95316303Sjkim * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL 96316303Sjkim * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES. THESE LIMITATIONS 97316303Sjkim * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY 98316303Sjkim * LIMITED REMEDY. 99316303Sjkim * 100316303Sjkim * 4.3. Licensee shall not export, either directly or indirectly, any of this 101316303Sjkim * software or system incorporating such software without first obtaining any 102316303Sjkim * required license or other approval from the U. S. Department of Commerce or 103316303Sjkim * any other agency or department of the United States Government. In the 104316303Sjkim * event Licensee exports any such software from the United States or 105316303Sjkim * re-exports any such software from a foreign destination, Licensee shall 106316303Sjkim * ensure that the distribution and export/re-export of the software is in 107316303Sjkim * compliance with all laws, regulations, orders, or other restrictions of the 108316303Sjkim * U.S. Export Administration Regulations. Licensee agrees that neither it nor 109316303Sjkim * any of its subsidiaries will export/re-export any technical data, process, 110316303Sjkim * software, or service, directly or indirectly, to any country for which the 111316303Sjkim * United States government or any agency thereof requires an export license, 112316303Sjkim * other governmental approval, or letter of assurance, without first obtaining 113316303Sjkim * such license, approval or letter. 114316303Sjkim * 115316303Sjkim ***************************************************************************** 116316303Sjkim * 117316303Sjkim * Alternatively, you may choose to be licensed under the terms of the 118316303Sjkim * following license: 119316303Sjkim * 120217365Sjkim * Redistribution and use in source and binary forms, with or without 121217365Sjkim * modification, are permitted provided that the following conditions 122217365Sjkim * are met: 123217365Sjkim * 1. Redistributions of source code must retain the above copyright 124217365Sjkim * notice, this list of conditions, and the following disclaimer, 125217365Sjkim * without modification. 126217365Sjkim * 2. Redistributions in binary form must reproduce at minimum a disclaimer 127217365Sjkim * substantially similar to the "NO WARRANTY" disclaimer below 128217365Sjkim * ("Disclaimer") and any redistribution must be conditioned upon 129217365Sjkim * including a substantially similar Disclaimer requirement for further 130217365Sjkim * binary redistribution. 131217365Sjkim * 3. Neither the names of the above-listed copyright holders nor the names 132217365Sjkim * of any contributors may be used to endorse or promote products derived 133217365Sjkim * from this software without specific prior written permission. 134118611Snjl * 135316303Sjkim * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 136316303Sjkim * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 137316303Sjkim * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 138316303Sjkim * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 139316303Sjkim * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 140316303Sjkim * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 141316303Sjkim * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 142316303Sjkim * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 143316303Sjkim * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 144316303Sjkim * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 145316303Sjkim * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 146316303Sjkim * 147316303Sjkim * Alternatively, you may choose to be licensed under the terms of the 148217365Sjkim * GNU General Public License ("GPL") version 2 as published by the Free 149217365Sjkim * Software Foundation. 150118611Snjl * 151316303Sjkim *****************************************************************************/ 152118611Snjl 153217365Sjkim#include <contrib/dev/acpica/compiler/aslcompiler.h> 154217365Sjkim#include "aslcompiler.y.h" 155316303Sjkim#include <contrib/dev/acpica/include/acconvert.h> 156118611Snjl 157118611Snjl#include <stdlib.h> 158118611Snjl#include <string.h> 159118611SnjlYYSTYPE AslCompilerlval; 160118611Snjl 161118611Snjl/* 162118611Snjl * Generation: Use the following command line: 163118611Snjl * 164118611Snjl * flex.exe -PAslCompiler -i -o$(InputPath).c $(InputPath) 165118611Snjl * 166118611Snjl * -i: Scanner must be case-insensitive 167118611Snjl */ 168118611Snjl 169118611Snjl#define _COMPONENT ACPI_COMPILER 170234623Sjkim ACPI_MODULE_NAME ("aslscanner") 171228110Sjkim 172234623Sjkim 173228110Sjkim/* Local prototypes */ 174228110Sjkim 175234623Sjkimstatic void 176234623SjkimAslDoLineDirective (void); 177234623Sjkim 178316303Sjkimstatic BOOLEAN 179234623SjkimAslDoComment (void); 180234623Sjkim 181316303Sjkimstatic BOOLEAN 182234623SjkimAslDoCommentType2 (void); 183234623Sjkim 184234623Sjkimstatic char 185234623SjkimAslDoStringLiteral (void); 186234623Sjkim 187234623Sjkimstatic void 188118611Snjlcount (int type); 189118611Snjl 190234623Sjkim 191118611Snjl/*! [Begin] no source code translation */ 192118611Snjl 193118611Snjl%} 194228110Sjkim /* Definitions */ 195118611Snjl 196118611SnjlLeadNameChar [A-Za-z_] 197118611SnjlDigitChar [0-9] 198327557SjkimOctalChar [0-7] 199118611SnjlHexDigitChar [A-Fa-f0-9] 200118611SnjlRootChar [\\] 201118611SnjlNothing [] 202118611Snjl 203118611SnjlNameChar [A-Za-z_0-9] 204118611SnjlNameSeg1 {LeadNameChar}{NameChar} 205118611SnjlNameSeg2 {LeadNameChar}{NameChar}{NameChar} 206118611SnjlNameSeg3 {LeadNameChar}{NameChar}{NameChar}{NameChar} 207118611SnjlNameSeg {LeadNameChar}|{NameSeg1}|{NameSeg2}|{NameSeg3} 208118611Snjl 209118611SnjlNameString {RootChar}|{RootChar}{NamePath}|[\^]+{NamePath}|{NonEmptyNamePath} 210118611SnjlNamePath {NonEmptyNamePath}? 211118611SnjlNonEmptyNamePath {NameSeg}{NamePathTail}* 212118611SnjlNamePathTail [.]{NameSeg} 213118611Snjl 214118611Snjl%% 215228110Sjkim /* Rules */ 216118611Snjl 217118611Snjl[ ] { count (0); } 218193529Sjkim[\n] { count (0); } /* Handle files with both LF and CR/LF */ 219193529Sjkim[\r] { count (0); } /* termination on both Unix and Windows */ 220118611Snjl[ \t] { count (0); } 221118611Snjl 222118611Snjl 223272444Sjkim"/*" { if (!AslDoComment ()) {yyterminate ();} } 224272444Sjkim"//" { if (!AslDoCommentType2 ()) {yyterminate ();} } 225118611Snjl 226272444Sjkim"\"" { if (AslDoStringLiteral ()) {return (PARSEOP_STRING_LITERAL);} 227272444Sjkim else {yyterminate ();} } 228228110Sjkim";" { count (0); return(';'); } 229118611Snjl 230278970Sjkim /* ASL Extension: Standard C operators */ 231118611Snjl 232278970Sjkim"~" { count (3); return (PARSEOP_EXP_NOT); } 233278970Sjkim"!" { count (3); return (PARSEOP_EXP_LOGICAL_NOT); } 234278970Sjkim"*" { count (3); return (PARSEOP_EXP_MULTIPLY); } 235278970Sjkim"/" { count (3); return (PARSEOP_EXP_DIVIDE); } 236278970Sjkim"%" { count (3); return (PARSEOP_EXP_MODULO); } 237278970Sjkim"+" { count (3); return (PARSEOP_EXP_ADD); } 238278970Sjkim"-" { count (3); return (PARSEOP_EXP_SUBTRACT); } 239278970Sjkim">>" { count (3); return (PARSEOP_EXP_SHIFT_RIGHT); } 240278970Sjkim"<<" { count (3); return (PARSEOP_EXP_SHIFT_LEFT); } 241278970Sjkim"<" { count (3); return (PARSEOP_EXP_LESS); } 242278970Sjkim">" { count (3); return (PARSEOP_EXP_GREATER); } 243278970Sjkim"&" { count (3); return (PARSEOP_EXP_AND); } 244278970Sjkim"<=" { count (3); return (PARSEOP_EXP_LESS_EQUAL); } 245278970Sjkim">=" { count (3); return (PARSEOP_EXP_GREATER_EQUAL); } 246278970Sjkim"==" { count (3); return (PARSEOP_EXP_EQUAL); } 247278970Sjkim"!=" { count (3); return (PARSEOP_EXP_NOT_EQUAL); } 248278970Sjkim"|" { count (3); return (PARSEOP_EXP_OR); } 249278970Sjkim"&&" { count (3); return (PARSEOP_EXP_LOGICAL_AND); } 250278970Sjkim"||" { count (3); return (PARSEOP_EXP_LOGICAL_OR); } 251278970Sjkim"++" { count (3); return (PARSEOP_EXP_INCREMENT); } 252278970Sjkim"--" { count (3); return (PARSEOP_EXP_DECREMENT); } 253278970Sjkim"^ " { count (3); return (PARSEOP_EXP_XOR); } 254278970Sjkim 255278970Sjkim /* ASL Extension: Standard C assignment operators */ 256278970Sjkim 257278970Sjkim"=" { count (3); return (PARSEOP_EXP_EQUALS); } 258278970Sjkim"+=" { count (3); return (PARSEOP_EXP_ADD_EQ); } 259278970Sjkim"-=" { count (3); return (PARSEOP_EXP_SUB_EQ); } 260278970Sjkim"*=" { count (3); return (PARSEOP_EXP_MUL_EQ); } 261278970Sjkim"/=" { count (3); return (PARSEOP_EXP_DIV_EQ); } 262278970Sjkim"%=" { count (3); return (PARSEOP_EXP_MOD_EQ); } 263278970Sjkim"<<=" { count (3); return (PARSEOP_EXP_SHL_EQ); } 264278970Sjkim">>=" { count (3); return (PARSEOP_EXP_SHR_EQ); } 265278970Sjkim"&=" { count (3); return (PARSEOP_EXP_AND_EQ); } 266278970Sjkim"^=" { count (3); return (PARSEOP_EXP_XOR_EQ); } 267278970Sjkim"|=" { count (3); return (PARSEOP_EXP_OR_EQ); } 268278970Sjkim 269316303Sjkim"[" { count (3); return (PARSEOP_EXP_INDEX_LEFT); } 270316303Sjkim"]" { count (0); return (PARSEOP_EXP_INDEX_RIGHT); } 271316303Sjkim"(" { count (0); return (PARSEOP_OPEN_PAREN); } 272316303Sjkim")" { count (0); return (PARSEOP_CLOSE_PAREN); } 273278970Sjkim 274316303Sjkim"{" { count (0); return ('{'); } 275316303Sjkim"}" { count (0); return ('}'); } 276316303Sjkim"," { count (0); return (','); } 277298714Sjkim 278316303Sjkim 279278970Sjkim /* 280278970Sjkim * Begin standard ASL grammar 281278970Sjkim */ 282327557Sjkim[0-9][a-zA-Z0-9]* { AslCompilerlval.i = UtDoConstant ((char *) AslCompilertext); 283118611Snjl count (1); return (PARSEOP_INTEGER); } 284118611Snjl 285118611Snjl"Include" { count (1); return (PARSEOP_INCLUDE); } 286118611Snjl"External" { count (1); return (PARSEOP_EXTERNAL); } 287118611Snjl 288234623Sjkim /* 289234623Sjkim * The #line directive is emitted by the preprocessor and handled 290234623Sjkim * here in the main iASL lexer - simply set the line number and 291234623Sjkim * optionally the current filename. 292234623Sjkim */ 293234623Sjkim"#line" { AslDoLineDirective ();} 294234623Sjkim 295234623Sjkim 296228110Sjkim /**************************************************************************** 297228110Sjkim * 298228110Sjkim * Main ASL operators 299228110Sjkim * 300228110Sjkim ****************************************************************************/ 301118611Snjl 302118611Snjl"AccessAs" { count (1); return (PARSEOP_ACCESSAS); } 303228110Sjkim"Acquire" { count (3); return (PARSEOP_ACQUIRE); } 304228110Sjkim"Add" { count (3); return (PARSEOP_ADD); } 305228110Sjkim"Alias" { count (2); return (PARSEOP_ALIAS); } 306228110Sjkim"And" { count (3); return (PARSEOP_AND); } 307118611Snjl"BankField" { count (2); return (PARSEOP_BANKFIELD); } 308228110Sjkim"Break" { count (3); return (PARSEOP_BREAK); } 309228110Sjkim"BreakPoint" { count (3); return (PARSEOP_BREAKPOINT); } 310228110Sjkim"Buffer" { count (1); return (PARSEOP_BUFFER); } 311228110Sjkim"Case" { count (3); return (PARSEOP_CASE); } 312228110Sjkim"Concatenate" { count (3); return (PARSEOP_CONCATENATE); } 313228110Sjkim"ConcatenateResTemplate" { count (3); return (PARSEOP_CONCATENATERESTEMPLATE); } 314228110Sjkim"CondRefOf" { count (3); return (PARSEOP_CONDREFOF); } 315228110Sjkim"Connection" { count (2); return (PARSEOP_CONNECTION); } 316228110Sjkim"Continue" { count (3); return (PARSEOP_CONTINUE); } 317228110Sjkim"CopyObject" { count (3); return (PARSEOP_COPYOBJECT); } 318118611Snjl"CreateBitField" { count (2); return (PARSEOP_CREATEBITFIELD); } 319118611Snjl"CreateByteField" { count (2); return (PARSEOP_CREATEBYTEFIELD); } 320118611Snjl"CreateDWordField" { count (2); return (PARSEOP_CREATEDWORDFIELD); } 321118611Snjl"CreateField" { count (2); return (PARSEOP_CREATEFIELD); } 322118611Snjl"CreateQWordField" { count (2); return (PARSEOP_CREATEQWORDFIELD); } 323118611Snjl"CreateWordField" { count (2); return (PARSEOP_CREATEWORDFIELD); } 324118611Snjl"DataTableRegion" { count (2); return (PARSEOP_DATATABLEREGION); } 325228110Sjkim"Debug" { count (1); return (PARSEOP_DEBUG); } 326228110Sjkim"Decrement" { count (3); return (PARSEOP_DECREMENT); } 327228110Sjkim"Default" { count (3); return (PARSEOP_DEFAULT); } 328298714Sjkim"DefinitionBlock" { count (1); return (PARSEOP_DEFINITION_BLOCK); } 329228110Sjkim"DeRefOf" { count (3); return (PARSEOP_DEREFOF); } 330118611Snjl"Device" { count (2); return (PARSEOP_DEVICE); } 331228110Sjkim"Divide" { count (3); return (PARSEOP_DIVIDE); } 332228110Sjkim"Eisaid" { count (1); return (PARSEOP_EISAID); } 333228110Sjkim"Else" { count (3); return (PARSEOP_ELSE); } 334228110Sjkim"ElseIf" { count (3); return (PARSEOP_ELSEIF); } 335118611Snjl"Event" { count (2); return (PARSEOP_EVENT); } 336228110Sjkim"Fatal" { count (3); return (PARSEOP_FATAL); } 337118611Snjl"Field" { count (2); return (PARSEOP_FIELD); } 338228110Sjkim"FindSetLeftBit" { count (3); return (PARSEOP_FINDSETLEFTBIT); } 339228110Sjkim"FindSetRightBit" { count (3); return (PARSEOP_FINDSETRIGHTBIT); } 340228110Sjkim"FromBcd" { count (3); return (PARSEOP_FROMBCD); } 341138287Smarks"Function" { count (2); return (PARSEOP_FUNCTION); } 342118611Snjl"If" { count (3); return (PARSEOP_IF); } 343118611Snjl"Increment" { count (3); return (PARSEOP_INCREMENT); } 344118611Snjl"Index" { count (3); return (PARSEOP_INDEX); } 345228110Sjkim"IndexField" { count (2); return (PARSEOP_INDEXFIELD); } 346118611Snjl"LAnd" { count (3); return (PARSEOP_LAND); } 347118611Snjl"LEqual" { count (3); return (PARSEOP_LEQUAL); } 348118611Snjl"LGreater" { count (3); return (PARSEOP_LGREATER); } 349118611Snjl"LGreaterEqual" { count (3); return (PARSEOP_LGREATEREQUAL); } 350118611Snjl"LLess" { count (3); return (PARSEOP_LLESS); } 351118611Snjl"LLessEqual" { count (3); return (PARSEOP_LLESSEQUAL); } 352118611Snjl"LNot" { count (3); return (PARSEOP_LNOT); } 353118611Snjl"LNotEqual" { count (3); return (PARSEOP_LNOTEQUAL); } 354228110Sjkim"Load" { count (3); return (PARSEOP_LOAD); } 355118611Snjl"LoadTable" { count (3); return (PARSEOP_LOADTABLE); } 356118611Snjl"LOr" { count (3); return (PARSEOP_LOR); } 357118611Snjl"Match" { count (3); return (PARSEOP_MATCH); } 358228110Sjkim"Method" { count (2); return (PARSEOP_METHOD); } 359118611Snjl"Mid" { count (3); return (PARSEOP_MID); } 360118611Snjl"Mod" { count (3); return (PARSEOP_MOD); } 361118611Snjl"Multiply" { count (3); return (PARSEOP_MULTIPLY); } 362228110Sjkim"Mutex" { count (2); return (PARSEOP_MUTEX); } 363228110Sjkim"Name" { count (2); return (PARSEOP_NAME); } 364118611Snjl"NAnd" { count (3); return (PARSEOP_NAND); } 365245582Sjkim"Noop" { if (!AcpiGbl_IgnoreNoopOperator) {count (3); return (PARSEOP_NOOP);} } 366118611Snjl"NOr" { count (3); return (PARSEOP_NOR); } 367118611Snjl"Not" { count (3); return (PARSEOP_NOT); } 368228110Sjkim"Notify" { count (3); return (PARSEOP_NOTIFY); } 369118611Snjl"ObjectType" { count (3); return (PARSEOP_OBJECTTYPE); } 370228110Sjkim"Offset" { count (1); return (PARSEOP_OFFSET); } 371228110Sjkim"One" { count (1); return (PARSEOP_ONE); } 372228110Sjkim"Ones" { count (1); return (PARSEOP_ONES); } 373228110Sjkim"OperationRegion" { count (2); return (PARSEOP_OPERATIONREGION); } 374118611Snjl"Or" { count (3); return (PARSEOP_OR); } 375228110Sjkim"Package" { count (1); return (PARSEOP_PACKAGE); } 376228110Sjkim"PowerResource" { count (2); return (PARSEOP_POWERRESOURCE); } 377228110Sjkim"Processor" { count (2); return (PARSEOP_PROCESSOR); } 378118611Snjl"RefOf" { count (3); return (PARSEOP_REFOF); } 379228110Sjkim"Release" { count (3); return (PARSEOP_RELEASE); } 380228110Sjkim"Reset" { count (3); return (PARSEOP_RESET); } 381228110Sjkim"Return" { count (3); return (PARSEOP_RETURN); } 382228110Sjkim"Revision" { count (1); return (PARSEOP_REVISION); } 383228110Sjkim"Scope" { count (2); return (PARSEOP_SCOPE); } 384118611Snjl"ShiftLeft" { count (3); return (PARSEOP_SHIFTLEFT); } 385118611Snjl"ShiftRight" { count (3); return (PARSEOP_SHIFTRIGHT); } 386228110Sjkim"Signal" { count (3); return (PARSEOP_SIGNAL); } 387118611Snjl"SizeOf" { count (3); return (PARSEOP_SIZEOF); } 388228110Sjkim"Sleep" { count (3); return (PARSEOP_SLEEP); } 389228110Sjkim"Stall" { count (3); return (PARSEOP_STALL); } 390118611Snjl"Store" { count (3); return (PARSEOP_STORE); } 391118611Snjl"Subtract" { count (3); return (PARSEOP_SUBTRACT); } 392228110Sjkim"Switch" { count (3); return (PARSEOP_SWITCH); } 393228110Sjkim"ThermalZone" { count (2); return (PARSEOP_THERMALZONE); } 394138287Smarks"Timer" { count (3); return (PARSEOP_TIMER); } 395228110Sjkim"ToBcd" { count (3); return (PARSEOP_TOBCD); } 396118611Snjl"ToBuffer" { count (3); return (PARSEOP_TOBUFFER); } 397118611Snjl"ToDecimalString" { count (3); return (PARSEOP_TODECIMALSTRING); } 398118611Snjl"ToHexString" { count (3); return (PARSEOP_TOHEXSTRING); } 399118611Snjl"ToInteger" { count (3); return (PARSEOP_TOINTEGER); } 400118611Snjl"ToString" { count (3); return (PARSEOP_TOSTRING); } 401228110Sjkim"ToUuid" { count (1); return (PARSEOP_TOUUID); } 402228110Sjkim"Unicode" { count (1); return (PARSEOP_UNICODE); } 403228110Sjkim"Unload" { count (3); return (PARSEOP_UNLOAD); } 404118611Snjl"Wait" { count (3); return (PARSEOP_WAIT); } 405228110Sjkim"While" { count (3); return (PARSEOP_WHILE); } 406118611Snjl"XOr" { count (3); return (PARSEOP_XOR); } 407228110Sjkim"Zero" { count (1); return (PARSEOP_ZERO); } 408118611Snjl 409228110Sjkim /* Control method arguments and locals */ 410228110Sjkim 411118611Snjl"Arg0" { count (1); return (PARSEOP_ARG0); } 412118611Snjl"Arg1" { count (1); return (PARSEOP_ARG1); } 413118611Snjl"Arg2" { count (1); return (PARSEOP_ARG2); } 414118611Snjl"Arg3" { count (1); return (PARSEOP_ARG3); } 415118611Snjl"Arg4" { count (1); return (PARSEOP_ARG4); } 416118611Snjl"Arg5" { count (1); return (PARSEOP_ARG5); } 417118611Snjl"Arg6" { count (1); return (PARSEOP_ARG6); } 418118611Snjl"Local0" { count (1); return (PARSEOP_LOCAL0); } 419118611Snjl"Local1" { count (1); return (PARSEOP_LOCAL1); } 420118611Snjl"Local2" { count (1); return (PARSEOP_LOCAL2); } 421118611Snjl"Local3" { count (1); return (PARSEOP_LOCAL3); } 422118611Snjl"Local4" { count (1); return (PARSEOP_LOCAL4); } 423118611Snjl"Local5" { count (1); return (PARSEOP_LOCAL5); } 424118611Snjl"Local6" { count (1); return (PARSEOP_LOCAL6); } 425118611Snjl"Local7" { count (1); return (PARSEOP_LOCAL7); } 426118611Snjl 427118611Snjl 428228110Sjkim /**************************************************************************** 429228110Sjkim * 430228110Sjkim * Resource Descriptor macros 431228110Sjkim * 432228110Sjkim ****************************************************************************/ 433118611Snjl 434118611Snjl"ResourceTemplate" { count (1); return (PARSEOP_RESOURCETEMPLATE); } 435228110Sjkim"RawDataBuffer" { count (1); return (PARSEOP_DATABUFFER); } 436228110Sjkim 437118611Snjl"DMA" { count (1); return (PARSEOP_DMA); } 438118611Snjl"DWordIO" { count (1); return (PARSEOP_DWORDIO); } 439118611Snjl"DWordMemory" { count (1); return (PARSEOP_DWORDMEMORY); } 440138287Smarks"DWordSpace" { count (1); return (PARSEOP_DWORDSPACE); } 441118611Snjl"EndDependentFn" { count (1); return (PARSEOP_ENDDEPENDENTFN); } 442138287Smarks"ExtendedIO" { count (1); return (PARSEOP_EXTENDEDIO); } 443138287Smarks"ExtendedMemory" { count (1); return (PARSEOP_EXTENDEDMEMORY); } 444138287Smarks"ExtendedSpace" { count (1); return (PARSEOP_EXTENDEDSPACE); } 445228110Sjkim"FixedDma" { count (1); return (PARSEOP_FIXEDDMA); } 446118611Snjl"FixedIO" { count (1); return (PARSEOP_FIXEDIO); } 447228110Sjkim"GpioInt" { count (1); return (PARSEOP_GPIO_INT); } 448228110Sjkim"GpioIo" { count (1); return (PARSEOP_GPIO_IO); } 449228110Sjkim"I2cSerialBus" { count (1); return (PARSEOP_I2C_SERIALBUS); } 450298714Sjkim"I2cSerialBusV2" { count (1); return (PARSEOP_I2C_SERIALBUS_V2); } 451118611Snjl"Interrupt" { count (1); return (PARSEOP_INTERRUPT); } 452118611Snjl"IO" { count (1); return (PARSEOP_IO); } 453228110Sjkim"IRQ" { count (1); return (PARSEOP_IRQ); } 454118611Snjl"IRQNoFlags" { count (1); return (PARSEOP_IRQNOFLAGS); } 455118611Snjl"Memory24" { count (1); return (PARSEOP_MEMORY24); } 456228110Sjkim"Memory32" { count (1); return (PARSEOP_MEMORY32); } 457118611Snjl"Memory32Fixed" { count (1); return (PARSEOP_MEMORY32FIXED); } 458322877Sjkim"PinConfig" { count (1); return (PARSEOP_PINCONFIG); } 459322877Sjkim"PinFunction" { count (1); return (PARSEOP_PINFUNCTION); } 460322877Sjkim"PinGroup" { count (1); return (PARSEOP_PINGROUP); } 461322877Sjkim"PinGroupConfig" { count (1); return (PARSEOP_PINGROUPCONFIG); } 462322877Sjkim"PinGroupFunction" { count (1); return (PARSEOP_PINGROUPFUNCTION); } 463118611Snjl"QWordIO" { count (1); return (PARSEOP_QWORDIO); } 464118611Snjl"QWordMemory" { count (1); return (PARSEOP_QWORDMEMORY); } 465138287Smarks"QWordSpace" { count (1); return (PARSEOP_QWORDSPACE); } 466118611Snjl"Register" { count (1); return (PARSEOP_REGISTER); } 467228110Sjkim"SpiSerialBus" { count (1); return (PARSEOP_SPI_SERIALBUS); } 468298714Sjkim"SpiSerialBusV2" { count (1); return (PARSEOP_SPI_SERIALBUS_V2); } 469118611Snjl"StartDependentFn" { count (1); return (PARSEOP_STARTDEPENDENTFN); } 470118611Snjl"StartDependentFnNoPri" { count (1); return (PARSEOP_STARTDEPENDENTFN_NOPRI); } 471228110Sjkim"UartSerialBus" { count (1); return (PARSEOP_UART_SERIALBUS); } 472298714Sjkim"UartSerialBusV2" { count (1); return (PARSEOP_UART_SERIALBUS_V2); } 473118611Snjl"VendorLong" { count (1); return (PARSEOP_VENDORLONG); } 474118611Snjl"VendorShort" { count (1); return (PARSEOP_VENDORSHORT); } 475118611Snjl"WordBusNumber" { count (1); return (PARSEOP_WORDBUSNUMBER); } 476118611Snjl"WordIO" { count (1); return (PARSEOP_WORDIO); } 477138287Smarks"WordSpace" { count (1); return (PARSEOP_WORDSPACE); } 478118611Snjl 479228110Sjkim 480228110Sjkim /**************************************************************************** 481228110Sjkim * 482228110Sjkim * Keywords used as arguments to ASL operators and macros 483228110Sjkim * 484228110Sjkim ****************************************************************************/ 485228110Sjkim 486228110Sjkim /* AccessAttribKeyword: Serial Bus Attributes (ACPI 5.0) */ 487228110Sjkim 488228110Sjkim"AttribQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 489228110Sjkim"AttribSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 490228110Sjkim"AttribByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 491228110Sjkim"AttribWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 492228110Sjkim"AttribBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 493228110Sjkim"AttribProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 494228110Sjkim"AttribBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 495228110Sjkim 496228110Sjkim /* AccessAttribKeyword: Legacy synonyms for above (pre-ACPI 5.0) */ 497228110Sjkim 498228110Sjkim"SMBQuick" { count (0); return (PARSEOP_ACCESSATTRIB_QUICK); } 499228110Sjkim"SMBSendReceive" { count (0); return (PARSEOP_ACCESSATTRIB_SND_RCV); } 500228110Sjkim"SMBByte" { count (0); return (PARSEOP_ACCESSATTRIB_BYTE); } 501228110Sjkim"SMBWord" { count (0); return (PARSEOP_ACCESSATTRIB_WORD); } 502228110Sjkim"SMBBlock" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK); } 503228110Sjkim"SMBProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_WORD_CALL); } 504228110Sjkim"SMBBlockProcessCall" { count (0); return (PARSEOP_ACCESSATTRIB_BLOCK_CALL); } 505228110Sjkim 506228110Sjkim /* AccessTypeKeyword: Field Access Types */ 507228110Sjkim 508228110Sjkim"AnyAcc" { count (0); return (PARSEOP_ACCESSTYPE_ANY); } 509228110Sjkim"ByteAcc" { count (0); return (PARSEOP_ACCESSTYPE_BYTE); } 510228110Sjkim"WordAcc" { count (0); return (PARSEOP_ACCESSTYPE_WORD); } 511228110Sjkim"DWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_DWORD); } 512228110Sjkim"QWordAcc" { count (0); return (PARSEOP_ACCESSTYPE_QWORD); } 513228110Sjkim"BufferAcc" { count (0); return (PARSEOP_ACCESSTYPE_BUF); } 514228110Sjkim 515228110Sjkim /* AddressingModeKeyword: Mode - Resource Descriptors (ACPI 5.0) */ 516228110Sjkim 517228110Sjkim"AddressingMode7Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_7BIT); } 518228110Sjkim"AddressingMode10Bit" { count (0); return (PARSEOP_ADDRESSINGMODE_10BIT); } 519228110Sjkim 520228110Sjkim /* AddressKeyword: ACPI memory range types */ 521228110Sjkim 522228110Sjkim"AddressRangeMemory" { count (0); return (PARSEOP_ADDRESSTYPE_MEMORY); } 523228110Sjkim"AddressRangeReserved" { count (0); return (PARSEOP_ADDRESSTYPE_RESERVED); } 524228110Sjkim"AddressRangeNVS" { count (0); return (PARSEOP_ADDRESSTYPE_NVS); } 525228110Sjkim"AddressRangeACPI" { count (0); return (PARSEOP_ADDRESSTYPE_ACPI); } 526228110Sjkim 527228110Sjkim /* BusMasterKeyword: DMA Bus Mastering */ 528228110Sjkim 529228110Sjkim"BusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_MASTER); } 530228110Sjkim"NotBusMaster" { count (0); return (PARSEOP_BUSMASTERTYPE_NOTMASTER); } 531228110Sjkim 532228110Sjkim /* ByteLengthKeyword: Bits per Byte - Resource Descriptors (ACPI 5.0) */ 533228110Sjkim 534228110Sjkim"DataBitsFive" { count (0); return (PARSEOP_BITSPERBYTE_FIVE); } 535228110Sjkim"DataBitsSix" { count (0); return (PARSEOP_BITSPERBYTE_SIX); } 536228110Sjkim"DataBitsSeven" { count (0); return (PARSEOP_BITSPERBYTE_SEVEN); } 537228110Sjkim"DataBitsEight" { count (0); return (PARSEOP_BITSPERBYTE_EIGHT); } 538228110Sjkim"DataBitsNine" { count (0); return (PARSEOP_BITSPERBYTE_NINE); } 539228110Sjkim 540228110Sjkim /* ClockPhaseKeyword: Resource Descriptors (ACPI 5.0) */ 541228110Sjkim 542228110Sjkim"ClockPhaseFirst" { count (0); return (PARSEOP_CLOCKPHASE_FIRST); } 543228110Sjkim"ClockPhaseSecond" { count (0); return (PARSEOP_CLOCKPHASE_SECOND); } 544228110Sjkim 545228110Sjkim /* ClockPolarityKeyword: Resource Descriptors (ACPI 5.0) */ 546228110Sjkim 547228110Sjkim"ClockPolarityLow" { count (0); return (PARSEOP_CLOCKPOLARITY_LOW); } 548228110Sjkim"ClockPolarityHigh" { count (0); return (PARSEOP_CLOCKPOLARITY_HIGH); } 549228110Sjkim 550228110Sjkim /* DecodeKeyword: Type of Memory Decoding - Resource Descriptors */ 551228110Sjkim 552228110Sjkim"PosDecode" { count (0); return (PARSEOP_DECODETYPE_POS); } 553228110Sjkim"SubDecode" { count (0); return (PARSEOP_DECODETYPE_SUB); } 554228110Sjkim 555228110Sjkim /* DmaTypeKeyword: DMA Types - DMA Resource Descriptor */ 556228110Sjkim 557228110Sjkim"Compatibility" { count (0); return (PARSEOP_DMATYPE_COMPATIBILITY); } 558228110Sjkim"TypeA" { count (0); return (PARSEOP_DMATYPE_A); } 559228110Sjkim"TypeB" { count (0); return (PARSEOP_DMATYPE_B); } 560228110Sjkim"TypeF" { count (0); return (PARSEOP_DMATYPE_F); } 561228110Sjkim 562228110Sjkim /* EndianKeyword: Endian type - Resource Descriptor (ACPI 5.0) */ 563228110Sjkim 564228110Sjkim"LittleEndian" { count (0); return (PARSEOP_ENDIAN_LITTLE); } 565228110Sjkim"BigEndian" { count (0); return (PARSEOP_ENDIAN_BIG); } 566228110Sjkim 567228110Sjkim /* ExtendedAttribKeyword: Bus attributes, AccessAs operator (ACPI 5.0) */ 568228110Sjkim 569228110Sjkim"AttribBytes" { count (0); return (PARSEOP_ACCESSATTRIB_MULTIBYTE); } 570228110Sjkim"AttribRawBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_BYTES); } 571228110Sjkim"AttribRawProcessBytes" { count (0); return (PARSEOP_ACCESSATTRIB_RAW_PROCESS); } 572228110Sjkim 573228110Sjkim /* FlowControlKeyword: Resource Descriptors (ACPI 5.0) */ 574228110Sjkim 575228110Sjkim"FlowControlHardware" { count (0); return (PARSEOP_FLOWCONTROL_HW); } 576228110Sjkim"FlowControlNone" { count (0); return (PARSEOP_FLOWCONTROL_NONE); } 577228110Sjkim"FlowControlXon" { count (0); return (PARSEOP_FLOWCONTROL_SW); } 578228110Sjkim 579228110Sjkim /* InterruptLevelKeyword: Interrupt Active Types */ 580228110Sjkim 581228110Sjkim"ActiveBoth" { count (0); return (PARSEOP_INTLEVEL_ACTIVEBOTH); } 582228110Sjkim"ActiveHigh" { count (0); return (PARSEOP_INTLEVEL_ACTIVEHIGH); } 583228110Sjkim"ActiveLow" { count (0); return (PARSEOP_INTLEVEL_ACTIVELOW); } 584228110Sjkim 585228110Sjkim /* InterruptTypeKeyword: Interrupt Types */ 586228110Sjkim 587228110Sjkim"Edge" { count (0); return (PARSEOP_INTTYPE_EDGE); } 588228110Sjkim"Level" { count (0); return (PARSEOP_INTTYPE_LEVEL); } 589228110Sjkim 590228110Sjkim /* IoDecodeKeyword: Type of Memory Decoding - Resource Descriptors */ 591228110Sjkim 592228110Sjkim"Decode10" { count (0); return (PARSEOP_IODECODETYPE_10); } 593228110Sjkim"Decode16" { count (0); return (PARSEOP_IODECODETYPE_16); } 594228110Sjkim 595228110Sjkim /* IoRestrictionKeyword: I/O Restriction - GPIO Resource Descriptors (ACPI 5.0) */ 596228110Sjkim 597228110Sjkim"IoRestrictionNone" { count (0); return (PARSEOP_IORESTRICT_NONE); } 598228110Sjkim"IoRestrictionInputOnly" { count (0); return (PARSEOP_IORESTRICT_IN); } 599228110Sjkim"IoRestrictionOutputOnly" { count (0); return (PARSEOP_IORESTRICT_OUT); } 600228110Sjkim"IoRestrictionNoneAndPreserve" { count (0); return (PARSEOP_IORESTRICT_PRESERVE); } 601228110Sjkim 602228110Sjkim /* LockRuleKeyword: Global Lock use for Field Operator */ 603228110Sjkim 604228110Sjkim"Lock" { count (0); return (PARSEOP_LOCKRULE_LOCK); } 605228110Sjkim"NoLock" { count (0); return (PARSEOP_LOCKRULE_NOLOCK); } 606228110Sjkim 607228110Sjkim /* MatchOpKeyword: Types for Match Operator */ 608228110Sjkim 609228110Sjkim"MTR" { count (0); return (PARSEOP_MATCHTYPE_MTR); } 610228110Sjkim"MEQ" { count (0); return (PARSEOP_MATCHTYPE_MEQ); } 611228110Sjkim"MLE" { count (0); return (PARSEOP_MATCHTYPE_MLE); } 612228110Sjkim"MLT" { count (0); return (PARSEOP_MATCHTYPE_MLT); } 613228110Sjkim"MGE" { count (0); return (PARSEOP_MATCHTYPE_MGE); } 614228110Sjkim"MGT" { count (0); return (PARSEOP_MATCHTYPE_MGT); } 615228110Sjkim 616228110Sjkim /* MaxKeyword: Max Range Type - Resource Descriptors */ 617228110Sjkim 618228110Sjkim"MaxFixed" { count (0); return (PARSEOP_MAXTYPE_FIXED); } 619228110Sjkim"MaxNotFixed" { count (0); return (PARSEOP_MAXTYPE_NOTFIXED); } 620228110Sjkim 621228110Sjkim /* MemTypeKeyword: Memory Types - Resource Descriptors */ 622228110Sjkim 623228110Sjkim"Cacheable" { count (0); return (PARSEOP_MEMTYPE_CACHEABLE); } 624228110Sjkim"WriteCombining" { count (0); return (PARSEOP_MEMTYPE_WRITECOMBINING); } 625228110Sjkim"Prefetchable" { count (0); return (PARSEOP_MEMTYPE_PREFETCHABLE); } 626228110Sjkim"NonCacheable" { count (0); return (PARSEOP_MEMTYPE_NONCACHEABLE); } 627228110Sjkim 628228110Sjkim /* MinKeyword: Min Range Type - Resource Descriptors */ 629228110Sjkim 630228110Sjkim"MinFixed" { count (0); return (PARSEOP_MINTYPE_FIXED); } 631228110Sjkim"MinNotFixed" { count (0); return (PARSEOP_MINTYPE_NOTFIXED); } 632228110Sjkim 633228110Sjkim /* ObjectTypeKeyword: ACPI Object Types */ 634228110Sjkim 635118611Snjl"UnknownObj" { count (0); return (PARSEOP_OBJECTTYPE_UNK); } 636118611Snjl"IntObj" { count (0); return (PARSEOP_OBJECTTYPE_INT); } 637118611Snjl"StrObj" { count (0); return (PARSEOP_OBJECTTYPE_STR); } 638118611Snjl"BuffObj" { count (0); return (PARSEOP_OBJECTTYPE_BUF); } 639118611Snjl"PkgObj" { count (0); return (PARSEOP_OBJECTTYPE_PKG); } 640118611Snjl"FieldUnitObj" { count (0); return (PARSEOP_OBJECTTYPE_FLD); } 641118611Snjl"DeviceObj" { count (0); return (PARSEOP_OBJECTTYPE_DEV); } 642118611Snjl"EventObj" { count (0); return (PARSEOP_OBJECTTYPE_EVT); } 643118611Snjl"MethodObj" { count (0); return (PARSEOP_OBJECTTYPE_MTH); } 644118611Snjl"MutexObj" { count (0); return (PARSEOP_OBJECTTYPE_MTX); } 645118611Snjl"OpRegionObj" { count (0); return (PARSEOP_OBJECTTYPE_OPR); } 646118611Snjl"PowerResObj" { count (0); return (PARSEOP_OBJECTTYPE_POW); } 647151937Sjkim"ProcessorObj" { count (0); return (PARSEOP_OBJECTTYPE_PRO); } 648118611Snjl"ThermalZoneObj" { count (0); return (PARSEOP_OBJECTTYPE_THZ); } 649118611Snjl"BuffFieldObj" { count (0); return (PARSEOP_OBJECTTYPE_BFF); } 650118611Snjl"DDBHandleObj" { count (0); return (PARSEOP_OBJECTTYPE_DDB); } 651118611Snjl 652228110Sjkim /* ParityKeyword: Resource Descriptors (ACPI 5.0) */ 653118611Snjl 654228110Sjkim"ParityTypeSpace" { count (0); return (PARSEOP_PARITYTYPE_SPACE); } 655228110Sjkim"ParityTypeMark" { count (0); return (PARSEOP_PARITYTYPE_MARK); } 656228110Sjkim"ParityTypeOdd" { count (0); return (PARSEOP_PARITYTYPE_ODD); } 657228110Sjkim"ParityTypeEven" { count (0); return (PARSEOP_PARITYTYPE_EVEN); } 658228110Sjkim"ParityTypeNone" { count (0); return (PARSEOP_PARITYTYPE_NONE); } 659118611Snjl 660228110Sjkim /* PinConfigKeyword: Pin Configuration - GPIO Resource Descriptors (ACPI 5.0) */ 661118611Snjl 662228110Sjkim"PullDefault" { count (0); return (PARSEOP_PIN_PULLDEFAULT); } 663228110Sjkim"PullUp" { count (0); return (PARSEOP_PIN_PULLUP); } 664228110Sjkim"PullDown" { count (0); return (PARSEOP_PIN_PULLDOWN); } 665228110Sjkim"PullNone" { count (0); return (PARSEOP_PIN_NOPULL); } 666118611Snjl 667228110Sjkim /* PolarityKeyword: Resource Descriptors (ACPI 5.0) */ 668228110Sjkim 669228110Sjkim"PolarityLow" { count (0); return (PARSEOP_DEVICEPOLARITY_LOW); } 670228110Sjkim"PolarityHigh" { count (0); return (PARSEOP_DEVICEPOLARITY_HIGH); } 671228110Sjkim 672228110Sjkim /* RangeTypeKeyword: I/O Range Types - Resource Descriptors */ 673228110Sjkim 674228110Sjkim"ISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_ISAONLY); } 675228110Sjkim"NonISAOnlyRanges" { count (0); return (PARSEOP_RANGETYPE_NONISAONLY); } 676228110Sjkim"EntireRange" { count (0); return (PARSEOP_RANGETYPE_ENTIRE); } 677228110Sjkim 678228110Sjkim /* ReadWriteKeyword: Memory Access Types - Resource Descriptors */ 679228110Sjkim 680228110Sjkim"ReadWrite" { count (0); return (PARSEOP_READWRITETYPE_BOTH); } 681228110Sjkim"ReadOnly" { count (0); return (PARSEOP_READWRITETYPE_READONLY); } 682228110Sjkim 683228110Sjkim /* RegionSpaceKeyword: Operation Region Address Space Types */ 684228110Sjkim 685118611Snjl"SystemIO" { count (0); return (PARSEOP_REGIONSPACE_IO); } 686118611Snjl"SystemMemory" { count (0); return (PARSEOP_REGIONSPACE_MEM); } 687118611Snjl"PCI_Config" { count (0); return (PARSEOP_REGIONSPACE_PCI); } 688118611Snjl"EmbeddedControl" { count (0); return (PARSEOP_REGIONSPACE_EC); } 689118611Snjl"SMBus" { count (0); return (PARSEOP_REGIONSPACE_SMBUS); } 690118611Snjl"SystemCMOS" { count (0); return (PARSEOP_REGIONSPACE_CMOS); } 691118611Snjl"PciBarTarget" { count (0); return (PARSEOP_REGIONSPACE_PCIBAR); } 692197104Sjkim"IPMI" { count (0); return (PARSEOP_REGIONSPACE_IPMI); } 693228110Sjkim"GeneralPurposeIo" { count (0); return (PARSEOP_REGIONSPACE_GPIO); } /* ACPI 5.0 */ 694228110Sjkim"GenericSerialBus" { count (0); return (PARSEOP_REGIONSPACE_GSBUS); } /* ACPI 5.0 */ 695235945Sjkim"PCC" { count (0); return (PARSEOP_REGIONSPACE_PCC); } /* ACPI 5.0 */ 696228110Sjkim"FFixedHW" { count (0); return (PARSEOP_REGIONSPACE_FFIXEDHW); } 697118611Snjl 698228110Sjkim /* ResourceTypeKeyword: Resource Usage - Resource Descriptors */ 699118611Snjl 700228110Sjkim"ResourceConsumer" { count (0); return (PARSEOP_RESOURCETYPE_CONSUMER); } 701228110Sjkim"ResourceProducer" { count (0); return (PARSEOP_RESOURCETYPE_PRODUCER); } 702118611Snjl 703228110Sjkim /* SerializeRuleKeyword: Control Method Serialization */ 704118611Snjl 705228110Sjkim"Serialized" { count (0); return (PARSEOP_SERIALIZERULE_SERIAL); } 706228110Sjkim"NotSerialized" { count (0); return (PARSEOP_SERIALIZERULE_NOTSERIAL); } 707118611Snjl 708228110Sjkim /* ShareTypeKeyword: Interrupt Sharing - Resource Descriptors */ 709118611Snjl 710228110Sjkim"Shared" { count (0); return (PARSEOP_SHARETYPE_SHARED); } 711228110Sjkim"Exclusive" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVE); } 712228110Sjkim"SharedAndWake" { count (0); return (PARSEOP_SHARETYPE_SHAREDWAKE); } /* ACPI 5.0 */ 713228110Sjkim"ExclusiveAndWake" { count (0); return (PARSEOP_SHARETYPE_EXCLUSIVEWAKE); } /* ACPI 5.0 */ 714118611Snjl 715228110Sjkim /* SlaveModeKeyword: Resource Descriptors (ACPI 5.0) */ 716118611Snjl 717228110Sjkim"ControllerInitiated" { count (0); return (PARSEOP_SLAVEMODE_CONTROLLERINIT); } 718228110Sjkim"DeviceInitiated" { count (0); return (PARSEOP_SLAVEMODE_DEVICEINIT); } 719118611Snjl 720228110Sjkim /* StopBitsKeyword: Resource Descriptors (ACPI 5.0) */ 721118611Snjl 722228110Sjkim"StopBitsOne" { count (0); return (PARSEOP_STOPBITS_ONE); } 723228110Sjkim"StopBitsOnePlusHalf" { count (0); return (PARSEOP_STOPBITS_ONEPLUSHALF); } 724228110Sjkim"StopBitsTwo" { count (0); return (PARSEOP_STOPBITS_TWO); } 725228110Sjkim"StopBitsZero" { count (0); return (PARSEOP_STOPBITS_ZERO); } 726118611Snjl 727228110Sjkim /* TransferWidthKeyword: DMA Widths - Fixed DMA Resource Descriptor (ACPI 5.0) */ 728118611Snjl 729228110Sjkim"Width8bit" { count (0); return (PARSEOP_XFERSIZE_8); } 730228110Sjkim"Width16bit" { count (0); return (PARSEOP_XFERSIZE_16); } 731228110Sjkim"Width32bit" { count (0); return (PARSEOP_XFERSIZE_32); } 732228110Sjkim"Width64bit" { count (0); return (PARSEOP_XFERSIZE_64); } 733228110Sjkim"Width128bit" { count (0); return (PARSEOP_XFERSIZE_128); } 734228110Sjkim"Width256bit" { count (0); return (PARSEOP_XFERSIZE_256); } 735118611Snjl 736228110Sjkim /* TranslationKeyword: Translation Density Types - Resource Descriptors */ 737118611Snjl 738228110Sjkim"SparseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_SPARSE); } 739228110Sjkim"DenseTranslation" { count (0); return (PARSEOP_TRANSLATIONTYPE_DENSE); } 740118611Snjl 741228110Sjkim /* TypeKeyword: Translation Types - Resource Descriptors */ 742118611Snjl 743118611Snjl"TypeTranslation" { count (0); return (PARSEOP_TYPE_TRANSLATION); } 744118611Snjl"TypeStatic" { count (0); return (PARSEOP_TYPE_STATIC); } 745118611Snjl 746228110Sjkim /* UpdateRuleKeyword: Field Update Rules */ 747118611Snjl 748228110Sjkim"Preserve" { count (0); return (PARSEOP_UPDATERULE_PRESERVE); } 749228110Sjkim"WriteAsOnes" { count (0); return (PARSEOP_UPDATERULE_ONES); } 750228110Sjkim"WriteAsZeros" { count (0); return (PARSEOP_UPDATERULE_ZEROS); } 751118611Snjl 752228110Sjkim /* WireModeKeyword: SPI Wire Mode - Resource Descriptors (ACPI 5.0) */ 753228110Sjkim 754228110Sjkim"FourWireMode" { count (0); return (PARSEOP_WIREMODE_FOUR); } 755228110Sjkim"ThreeWireMode" { count (0); return (PARSEOP_WIREMODE_THREE); } 756228110Sjkim 757228110Sjkim /* XferTypeKeyword: DMA Transfer Types */ 758228110Sjkim 759228110Sjkim"Transfer8" { count (0); return (PARSEOP_XFERTYPE_8); } 760228110Sjkim"Transfer8_16" { count (0); return (PARSEOP_XFERTYPE_8_16); } 761228110Sjkim"Transfer16" { count (0); return (PARSEOP_XFERTYPE_16); } 762228110Sjkim 763278970Sjkim /* ToPld macro */ 764278970Sjkim 765278970Sjkim"ToPLD" { count (0); return (PARSEOP_TOPLD); } 766278970Sjkim 767278970Sjkim"PLD_Revision" { count (0); return (PARSEOP_PLD_REVISION); } 768278970Sjkim"PLD_IgnoreColor" { count (0); return (PARSEOP_PLD_IGNORECOLOR); } 769278970Sjkim"PLD_Red" { count (0); return (PARSEOP_PLD_RED); } 770278970Sjkim"PLD_Green" { count (0); return (PARSEOP_PLD_GREEN); } 771278970Sjkim"PLD_Blue" { count (0); return (PARSEOP_PLD_BLUE); } 772278970Sjkim"PLD_Width" { count (0); return (PARSEOP_PLD_WIDTH); } 773278970Sjkim"PLD_Height" { count (0); return (PARSEOP_PLD_HEIGHT); } 774278970Sjkim"PLD_UserVisible" { count (0); return (PARSEOP_PLD_USERVISIBLE); } 775278970Sjkim"PLD_Dock" { count (0); return (PARSEOP_PLD_DOCK); } 776278970Sjkim"PLD_Lid" { count (0); return (PARSEOP_PLD_LID); } 777278970Sjkim"PLD_Panel" { count (0); return (PARSEOP_PLD_PANEL); } 778278970Sjkim"PLD_VerticalPosition" { count (0); return (PARSEOP_PLD_VERTICALPOSITION); } 779278970Sjkim"PLD_HorizontalPosition" { count (0); return (PARSEOP_PLD_HORIZONTALPOSITION); } 780278970Sjkim"PLD_Shape" { count (0); return (PARSEOP_PLD_SHAPE); } 781278970Sjkim"PLD_GroupOrientation" { count (0); return (PARSEOP_PLD_GROUPORIENTATION); } 782278970Sjkim"PLD_GroupToken" { count (0); return (PARSEOP_PLD_GROUPTOKEN); } 783278970Sjkim"PLD_GroupPosition" { count (0); return (PARSEOP_PLD_GROUPPOSITION); } 784278970Sjkim"PLD_Bay" { count (0); return (PARSEOP_PLD_BAY); } 785278970Sjkim"PLD_Ejectable" { count (0); return (PARSEOP_PLD_EJECTABLE); } 786278970Sjkim"PLD_EjectRequired" { count (0); return (PARSEOP_PLD_EJECTREQUIRED); } 787278970Sjkim"PLD_CabinetNumber" { count (0); return (PARSEOP_PLD_CABINETNUMBER); } 788278970Sjkim"PLD_CardCageNumber" { count (0); return (PARSEOP_PLD_CARDCAGENUMBER); } 789278970Sjkim"PLD_Reference" { count (0); return (PARSEOP_PLD_REFERENCE); } 790278970Sjkim"PLD_Rotation" { count (0); return (PARSEOP_PLD_ROTATION); } 791278970Sjkim"PLD_Order" { count (0); return (PARSEOP_PLD_ORDER); } 792278970Sjkim"PLD_Reserved" { count (0); return (PARSEOP_PLD_RESERVED); } 793278970Sjkim"PLD_VerticalOffset" { count (0); return (PARSEOP_PLD_VERTICALOFFSET); } 794278970Sjkim"PLD_HorizontalOffset" { count (0); return (PARSEOP_PLD_HORIZONTALOFFSET); } 795278970Sjkim 796278970Sjkim 797278970Sjkim /* printf debug macros */ 798298714Sjkim 799278970Sjkim"printf" { count (0); return (PARSEOP_PRINTF); } 800278970Sjkim"fprintf" { count (0); return (PARSEOP_FPRINTF); } 801278970Sjkim 802298714Sjkim /* Other macros */ 803298714Sjkim 804298714Sjkim"For" { count (0); return (PARSEOP_FOR); } 805298714Sjkim 806228110Sjkim /* Predefined compiler names */ 807228110Sjkim 808218590Sjkim"__DATE__" { count (0); return (PARSEOP___DATE__); } 809218590Sjkim"__FILE__" { count (0); return (PARSEOP___FILE__); } 810218590Sjkim"__LINE__" { count (0); return (PARSEOP___LINE__); } 811228110Sjkim"__PATH__" { count (0); return (PARSEOP___PATH__); } 812322877Sjkim"__METHOD__" { count (0); return (PARSEOP___METHOD__); } 813118611Snjl 814118611Snjl{NameSeg} { char *s; 815118611Snjl count (0); 816327557Sjkim s=UtLocalCacheCalloc (ACPI_NAME_SIZE + 1); 817118611Snjl if (strcmp (AslCompilertext, "\\")) 818118611Snjl { 819118611Snjl strcpy (s, "____"); 820151937Sjkim AcpiUtStrupr (AslCompilertext); 821118611Snjl } 822118611Snjl memcpy (s, AslCompilertext, strlen (AslCompilertext)); 823118611Snjl AslCompilerlval.s = s; 824118611Snjl DbgPrint (ASL_PARSE_OUTPUT, "NameSeg: %s\n", s); 825118611Snjl return (PARSEOP_NAMESEG); } 826118611Snjl 827118611Snjl{NameString} { char *s; 828118611Snjl count (0); 829327557Sjkim s=UtLocalCacheCalloc (strlen (AslCompilertext)+1); 830151937Sjkim AcpiUtStrupr (AslCompilertext); 831118611Snjl strcpy (s, AslCompilertext); 832118611Snjl AslCompilerlval.s = s; 833118611Snjl DbgPrint (ASL_PARSE_OUTPUT, "NameString: %s\n", s); 834118611Snjl return (PARSEOP_NAMESTRING); } 835118611Snjl 836118611Snjl. { count (1); 837284583Sjkim if (isprint ((int) *AslCompilertext)) 838283092Sjkim { 839283092Sjkim sprintf (MsgBuffer, 840283092Sjkim "Invalid character (%c), expecting ASL keyword or name", 841283092Sjkim *AslCompilertext); 842283092Sjkim } 843283092Sjkim else 844283092Sjkim { 845283092Sjkim sprintf (MsgBuffer, 846283092Sjkim "Invalid character (0x%2.2X), expecting ASL keyword or name", 847283092Sjkim *AslCompilertext); 848283092Sjkim } 849118611Snjl AslCompilererror (MsgBuffer);} 850118611Snjl 851118611Snjl<<EOF>> { if (AslPopInputFileStack ()) 852272444Sjkim {yyterminate();} 853118611Snjl else 854272444Sjkim {return (PARSEOP_INCLUDE_END);} }; 855118611Snjl 856118611Snjl%% 857118611Snjl 858118611Snjl/*! [End] no source code translation !*/ 859118611Snjl 860234623Sjkim/* 861234623Sjkim * Bring in the scanner support routines 862234623Sjkim */ 863234623Sjkim#include <contrib/dev/acpica/compiler/aslsupport.l> 864