aslsupport.l revision 199767f8919635c4928607450d9e0abb932109ce
/******************************************************************************
*
* NOTE: Included into aslcompile.l, not compiled by itself.
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2015, Intel Corp.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions, and the following disclaimer,
* without modification.
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
* substantially similar to the "NO WARRANTY" disclaimer below
* ("Disclaimer") and any redistribution must be conditioned upon
* including a substantially similar Disclaimer requirement for further
* binary redistribution.
* 3. Neither the names of the above-listed copyright holders nor the names
* of any contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* Alternatively, this software may be distributed under the terms of the
* GNU General Public License ("GPL") version 2 as published by the Free
* Software Foundation.
*
* NO WARRANTY
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGES.
*/
/* Configuration */
#define ASL_SPACES_PER_TAB 4
#define ASL_NORMAL_CHAR 0
#define ASL_ESCAPE_SEQUENCE 1
#define ASL_OCTAL_CONSTANT 2
#define ASL_HEX_CONSTANT 3
/* File node - used for "Include" operator file stack */
typedef struct asl_file_node
{
char *Filename;
struct asl_file_node *Next;
/* File stack for the "Include" operator (NOT #include operator) */
/*******************************************************************************
*
* FUNCTION: AslParserCleanup
*
* Used to delete the current buffer
*
******************************************************************************/
void
void)
{
}
/*******************************************************************************
*
* FUNCTION: AslDoLineDirective
*
* PARAMETERS: None. Uses input() to access current source code line
*
* RETURN: Updates global line number and filename
*
* DESCRIPTION: Handle #line directives emitted by the preprocessor.
*
* The #line directive is emitted by the preprocesser, and is used to
* pass through line numbers from the original source code file to the
* preprocessor output file (.i). This allows any compiler-generated
* error messages to be displayed with the correct line number.
*
******************************************************************************/
static void
void)
{
int c;
char *Token;
char *Filename;
UINT32 i;
/* Eat the entire line that contains the #line directive */
{
*Gbl_LineBufPtr = c;
}
*Gbl_LineBufPtr = 0;
/* First argument is the actual line number */
if (!Token)
{
goto ResetAndExit;
}
/* First argument is the line number */
/* Emit the appropriate number of newlines */
Gbl_CurrentColumn = 0;
if (LineNumber > Gbl_CurrentLineNumber)
{
for (i = 0; i < (LineNumber - Gbl_CurrentLineNumber); i++)
{
}
}
/* Second argument is the optional filename (in double quotes) */
if (Token)
{
}
/* Third argument is not supported at this time */
/* Reset globals for a new line */
Gbl_CurrentColumn = 0;
}
/*******************************************************************************
*
* FUNCTION: AslPopInputFileStack
*
* PARAMETERS: None
*
* RETURN: 0 if a node was popped, -1 otherwise
*
* DESCRIPTION: Pop the top of the input file stack and point the parser to
* the saved parse buffer contained in the fnode. Also, set the
* global line counters to the saved values. This function is
* called when an include file reaches EOF.
*
******************************************************************************/
int
void)
{
"\nPop InputFile Stack, Fnode %p\n\n", Fnode);
if (!Fnode)
{
return (-1);
}
/* Close the current include file */
/* Update the top-of-stack */
/* Reset global line counter and filename */
/* Point the parser to the popped file */
/* All done with this node */
return (0);
}
/*******************************************************************************
*
* FUNCTION: AslPushInputFileStack
*
* PARAMETERS: InputFile - Open file pointer
* Filename - Name of the file
*
* RETURN: None
*
* DESCRIPTION: Push the InputFile onto the file stack, and point the parser
* to this file. Called when an include file is successfully
* opened.
*
******************************************************************************/
void
char *Filename)
{
/* Save the current state in an Fnode */
/* Push it on the stack */
/* Point the parser to this file */
"\nPush InputFile Stack, returning %p\n\n", InputFile);
/* Reset the global line count and filename */
}
/*******************************************************************************
*
* FUNCTION: AslResetCurrentLineBuffer
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
*
******************************************************************************/
void
void)
{
{
}
Gbl_CurrentColumn = 0;
}
/*******************************************************************************
*
* FUNCTION: AslInsertLineBuffer
*
* PARAMETERS: SourceChar - One char from the input ASL source file
*
* RETURN: None
*
* DESCRIPTION: Put one character of the source file into the temp line buffer
*
******************************************************************************/
void
int SourceChar)
{
UINT32 i;
if (SourceChar == EOF)
{
return;
}
/* Handle tabs. Convert to spaces */
if (SourceChar == '\t')
{
SourceChar = ' ';
}
for (i = 0; i < Count; i++)
{
/* Insert the character into the line buffer */
if (Gbl_LineBufPtr >
{
#if 0
/*
* Warning if we have split a long source line.
* <Probably overkill>
*/
#endif
}
else if (SourceChar == '\n')
{
/* End of line */
}
}
}
/*******************************************************************************
*
* FUNCTION: count
*
* PARAMETERS: yytext - Contains the matched keyword.
* 0 = anything except a keyword
* 1 = pseudo-keywords
* 2 = non-executable ASL keywords
* 3 = executable ASL keywords
*
* RETURN: None
*
* DESCRIPTION: Count keywords and put them into the line buffer
*
******************************************************************************/
static void
count (
int Type)
{
int i;
switch (Type)
{
case 2:
break;
case 3:
break;
default:
break;
}
{
AslInsertLineBuffer (yytext[i]);
*Gbl_LineBufPtr = 0;
}
}
/*******************************************************************************
*
* FUNCTION: AslDoComment
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Process a standard comment.
*
******************************************************************************/
static char
void)
{
int c;
int c1 = 0;
AslInsertLineBuffer ('/');
AslInsertLineBuffer ('*');
loop:
/* Eat chars until end-of-comment */
{
AslInsertLineBuffer (c);
c1 = c;
}
if (c == EOF)
{
goto EarlyEOF;
}
/*
* Check for nested comment -- can help catch cases where a previous
* comment was accidently left unterminated
*/
{
}
/* Comment is closed only if the NEXT character is a slash */
AslInsertLineBuffer (c);
{
goto loop;
}
{
goto EarlyEOF;
}
return (TRUE);
/*
* Premature End-Of-File
*/
return (FALSE);
}
/*******************************************************************************
*
* FUNCTION: AslDoCommentType2
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Process a new "//" comment.
*
******************************************************************************/
static char
void)
{
int c;
AslInsertLineBuffer ('/');
AslInsertLineBuffer ('/');
{
AslInsertLineBuffer (c);
}
if (c == EOF)
{
/* End of file is OK, change to newline. Let parser detect EOF later */
c = '\n';
}
AslInsertLineBuffer (c);
return (TRUE);
}
/*******************************************************************************
*
* FUNCTION: AslDoStringLiteral
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Process a string literal (surrounded by quotes)
*
******************************************************************************/
static char
void)
{
char *StringBuffer = MsgBuffer;
char *CleanString;
int StringChar;
UINT32 i = 0;
char ConvertBuffer[4];
/*
* Eat chars until end-of-literal.
* NOTE: Put back the original surrounding quotes into the
* source line buffer.
*/
AslInsertLineBuffer ('\"');
{
switch (State)
{
case ASL_NORMAL_CHAR:
switch (StringChar)
{
case '\\':
/*
* Special handling for backslash-escape sequence. We will
* toss the backslash and translate the escape char(s).
*/
continue;
case '\"':
/* String terminator */
goto CompletedString;
default:
break;
}
break;
case ASL_ESCAPE_SEQUENCE:
switch (StringChar)
{
case 'a':
break;
case 'b':
break;
case 'f':
break;
case 'n':
break;
case 'r':
break;
case 't':
break;
case 'v':
break;
case 'x':
i = 0;
continue;
case '\'': /* Single Quote */
case '\"': /* Double Quote */
case '\\': /* Backslash */
break;
default:
/* Check for an octal digit (0-7) */
if (ACPI_IS_OCTAL_DIGIT (StringChar))
{
ConvertBuffer[0] = StringChar;
i = 1;
continue;
}
/* Unknown escape sequence issue warning, but use the character */
break;
}
break;
case ASL_OCTAL_CONSTANT:
/* Up to three octal digits allowed */
if (!ACPI_IS_OCTAL_DIGIT (StringChar) ||
(i > 2))
{
/*
* Reached end of the constant. Convert the assembled ASCII
* string and resume processing of the next character
*/
ConvertBuffer[i] = 0;
/* Check for NULL or non-ascii character (ignore if so) */
{
}
else
{
*StringBuffer = (char) Digit;
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
goto DoCharacter;
break;
}
/* Append another digit of the constant */
ConvertBuffer[i] = StringChar;
i++;
continue;
case ASL_HEX_CONSTANT:
/* Up to two hex digits allowed */
if (!isxdigit (StringChar) ||
(i > 1))
{
/*
* Reached end of the constant. Convert the assembled ASCII
* string and resume processing of the next character
*/
ConvertBuffer[i] = 0;
/* Check for NULL or non-ascii character (ignore if so) */
{
}
else
{
*StringBuffer = (char) Digit;
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
goto DoCharacter;
break;
}
/* Append another digit of the constant */
ConvertBuffer[i] = StringChar;
i++;
continue;
default:
break;
}
/* Save the finished character */
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
/*
* Premature End-Of-File
*/
return (FALSE);
/*
* Null terminate the input string and copy string to a new buffer
*/
*StringBuffer = 0;
if (!CleanString)
{
return (FALSE);
}
return (TRUE);
/* Literal was too long */
return (FALSE);
}