d/freebsd-nq
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge ACPICA 20120420.

Browse Source
This commit is contained in:
Jung-uk Kim 2012-04-23 23:05:14 +00:00
commit eef1b955be
35 changed files with 1630 additions and 1388 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
sys/contrib/dev/acpica/acpica_prep.sh
View File

@ -31,7 +31,7 @@ src_headers="acapps.h accommon.h acconfig.h acdebug.h acdisasm.h \
actbl2.h actbl3.h actypes.h acutils.h amlcode.h amlresrc.h \ actbl2.h actbl3.h actypes.h acutils.h amlcode.h amlresrc.h \
platform/acenv.h platform/acfreebsd.h platform/acgcc.h" platform/acenv.h platform/acfreebsd.h platform/acgcc.h"
comp_headers="aslcompiler.h asldefine.h aslglobal.h aslmessages.h \ comp_headers="aslcompiler.h asldefine.h aslglobal.h aslmessages.h \
asltypes.h dtcompiler.h dttemplate.h preprocess.h" aslsupport.l asltypes.h dtcompiler.h dttemplate.h preprocess.h"
platform_headers="acfreebsd.h acgcc.h" platform_headers="acfreebsd.h acgcc.h"
# pre-clean # pre-clean

67
sys/contrib/dev/acpica/changes.txt
View File

@ -1,3 +1,70 @@
----------------------------------------
20 April 2012. Summary of changes for version 20120420:
This release is available at www.acpica.org/downloads.
The ACPI 5.0 specification is available at www.acpi.info.
1) ACPICA Core Subsystem:
Implemented support for multiple notify handlers. This change adds support to
allow multiple system and device notify handlers on Device, Thermal Zone, and
Processor objects. This can simplify the host OS notification implementation.
Also re-worked and restructured the entire notify support code to simplify
handler installation, handler removal, notify event queuing, and notify
dispatch to handler(s). Note: there can still only be two global notify
handlers - one for system notifies and one for device notifies. There are no
changes to the existing handler install/remove interfaces. Lin Ming, Bob
Moore, Rafael Wysocki.
Fixed a regression in the package repair code where the object reference
count was calculated incorrectly. Regression was introduced in the commit
"Support to add Package wrappers".
Fixed a couple possible memory leaks in the AML parser, in the error recovery
path. Jesper Juhl, Lin Ming.
Example Code and Data Size: These are the sizes for the OS-independent
acpica.lib produced by the Microsoft Visual C++ 9.0 32-bit compiler. The
debug version of the code includes the debug output trace mechanism and has a
much larger code and data size.
Previous Release:
Non-Debug Version: 92.9K Code, 25.0K Data, 117.9K Total
Debug Version: 172.5K Code, 73.2K Data, 245.7K Total
Current Release:
Non-Debug Version: 92.9K Code, 25.0K Data, 117.9K Total
Debug Version: 172.6K Code, 73.4K Data, 246.0K Total
2) iASL Compiler/Disassembler and Tools:
iASL: Fixed a problem with the resource descriptor support where the length
of the StartDependentFn and StartDependentFnNoPrio descriptors were not
included in cumulative descriptor offset, resulting in incorrect values for
resource tags within resource descriptors appearing after a StartDependent*
descriptor. Reported by Petr Vandrovec. ACPICA BZ 949.
iASL and Preprocessor: Implemented full support for the #line directive to
correctly track original source file line numbers through the .i preprocessor
output file - for error and warning messages.
iASL: Expand the allowable byte constants for address space IDs. Previously,
the allowable range was 0x80-0xFF (user-defined spaces), now the range is
0x0A-0xFF to allow for custom and new IDs without changing the compiler.
iASL: Add option to treat all warnings as errors (-we). ACPICA BZ 948.
iASL: Add option to completely disable the preprocessor (-Pn).
iASL: Now emit all error/warning messages to standard error (stderr) by
default (instead of the previous stdout).
ASL Test Suite (ASLTS): Reduce iASL warnings due to use of Switch(). Update
for resource descriptor offset fix above. Update/cleanup error output
routines. Enable and send iASL errors/warnings to an error logfile
(error.txt). Send all other iASL output to a logfile (compiler.txt). Fixed
several extraneous "unrecognized operator" messages.
---------------------------------------- ----------------------------------------
20 March 2012. Summary of changes for version 20120320: 20 March 2012. Summary of changes for version 20120320:

55
sys/contrib/dev/acpica/compiler/aslcompile.c
View File

@ -242,10 +242,10 @@ CmFlushSourceCode (
while (FlReadFile (ASL_FILE_INPUT, &Buffer, 1) != AE_ERROR) while (FlReadFile (ASL_FILE_INPUT, &Buffer, 1) != AE_ERROR)
{ {
InsertLineBuffer ((int) Buffer); AslInsertLineBuffer ((int) Buffer);
} }
ResetCurrentLineBuffer (); AslResetCurrentLineBuffer ();
} }
@ -457,16 +457,20 @@ CmDoCompile (
Event = UtBeginEvent ("Open input and output files"); Event = UtBeginEvent ("Open input and output files");
UtEndEvent (Event); UtEndEvent (Event);
/* Preprocessor */
Event = UtBeginEvent ("Preprocess input file"); Event = UtBeginEvent ("Preprocess input file");
PrDoPreprocess (); if (Gbl_PreprocessFlag)
UtEndEvent (Event);
if (Gbl_PreprocessOnly)
{ {
CmCleanupAndExit (); /* Preprocessor */
return 0;
PrDoPreprocess ();
if (Gbl_PreprocessOnly)
{
UtEndEvent (Event);
CmCleanupAndExit ();
return 0;
}
} }
UtEndEvent (Event);
/* Build the parse tree */ /* Build the parse tree */
@ -483,8 +487,17 @@ CmDoCompile (
if (!RootNode) if (!RootNode)
{ {
AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL, /*
NULL, "- Could not resolve parse tree root node"); * If there are no errors, then we have some sort of
* internal problem.
*/
Status = AslCheckForErrorExit ();
if (Status == AE_OK)
{
AslError (ASL_ERROR, ASL_MSG_COMPILER_INTERNAL,
NULL, "- Could not resolve parse tree root node");
}
goto ErrorExit; goto ErrorExit;
} }
@ -553,14 +566,14 @@ CmDoCompile (
if (Gbl_ParseOnlyFlag) if (Gbl_ParseOnlyFlag)
{ {
AePrintErrorLog (ASL_FILE_STDOUT); AePrintErrorLog (ASL_FILE_STDERR);
UtDisplaySummary (ASL_FILE_STDOUT); UtDisplaySummary (ASL_FILE_STDERR);
if (Gbl_DebugFlag) if (Gbl_DebugFlag)
{ {
/* Print error summary to the debug file */ /* Print error summary to the stdout also */
AePrintErrorLog (ASL_FILE_STDERR); AePrintErrorLog (ASL_FILE_STDOUT);
UtDisplaySummary (ASL_FILE_STDERR); UtDisplaySummary (ASL_FILE_STDOUT);
} }
UtEndEvent (FullCompile); UtEndEvent (FullCompile);
return 0; return 0;
@ -756,12 +769,12 @@ CmCleanupAndExit (
UINT32 i; UINT32 i;
AePrintErrorLog (ASL_FILE_STDOUT); AePrintErrorLog (ASL_FILE_STDERR);
if (Gbl_DebugFlag) if (Gbl_DebugFlag)
{ {
/* Print error summary to the debug file */ /* Print error summary to stdout also */
AePrintErrorLog (ASL_FILE_STDERR); AePrintErrorLog (ASL_FILE_STDOUT);
} }
DbgPrint (ASL_DEBUG_OUTPUT, "\n\nElapsed time for major events\n\n"); DbgPrint (ASL_DEBUG_OUTPUT, "\n\nElapsed time for major events\n\n");
@ -837,7 +850,9 @@ CmCleanupAndExit (
/* Delete the preprocessor output file (.i) unless -li flag is set */ /* Delete the preprocessor output file (.i) unless -li flag is set */
if (!Gbl_PreprocessorOutputFlag && Gbl_Files[ASL_FILE_PREPROCESSOR].Filename) if (!Gbl_PreprocessorOutputFlag &&
Gbl_PreprocessFlag &&
Gbl_Files[ASL_FILE_PREPROCESSOR].Filename)
{ {
if (remove (Gbl_Files[ASL_FILE_PREPROCESSOR].Filename)) if (remove (Gbl_Files[ASL_FILE_PREPROCESSOR].Filename))
{ {

15
sys/contrib/dev/acpica/compiler/aslcompiler.h
View File

@ -100,11 +100,11 @@ AslCompilerlex(
void); void);
void void
ResetCurrentLineBuffer ( AslResetCurrentLineBuffer (
void); void);
void void
InsertLineBuffer ( AslInsertLineBuffer (
int SourceChar); int SourceChar);
int int
@ -136,6 +136,11 @@ ACPI_STATUS
AslDoOneFile ( AslDoOneFile (
char *Filename); char *Filename);
ACPI_STATUS
AslCheckForErrorExit (
void);
/* /*
* aslcompile - compile mainline * aslcompile - compile mainline
*/ */
@ -645,7 +650,11 @@ FlPrintFile (
void void
FlSetLineNumber ( FlSetLineNumber (
ACPI_PARSE_OBJECT *Op); UINT32 LineNumber);
void
FlSetFilename (
char *Filename);
ACPI_STATUS ACPI_STATUS
FlOpenInputFile ( FlOpenInputFile (

711
sys/contrib/dev/acpica/compiler/aslcompiler.l
View File

@ -58,20 +58,26 @@ YYSTYPE AslCompilerlval;
*/ */
#define _COMPONENT ACPI_COMPILER #define _COMPONENT ACPI_COMPILER
ACPI_MODULE_NAME ("aslscan") ACPI_MODULE_NAME ("aslscanner")
/* Local prototypes */ /* Local prototypes */
char static void
comment (void); AslDoLineDirective (void);
char
comment2 (void); static char
void AslDoComment (void);
static char
AslDoCommentType2 (void);
static char
AslDoStringLiteral (void);
static void
count (int type); count (int type);
char
literal (void);
void
copy (void);
/*! [Begin] no source code translation */ /*! [Begin] no source code translation */
@ -104,10 +110,10 @@ NamePathTail [.]{NameSeg}
[ \t] { count (0); } [ \t] { count (0); }
"/*" { if (!comment ()) yyterminate (); } "/*" { if (!AslDoComment ()) yyterminate (); }
"//" { if (!comment2 ()) yyterminate (); } "//" { if (!AslDoCommentType2 ()) yyterminate (); }
"\"" { if (literal ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); } "\"" { if (AslDoStringLiteral ()) return (PARSEOP_STRING_LITERAL); else yyterminate (); }
";" { count (0); return(';'); } ";" { count (0); return(';'); }
@ -116,10 +122,16 @@ NamePathTail [.]{NameSeg}
count (1); return (PARSEOP_INTEGER); } count (1); return (PARSEOP_INTEGER); }
"Include" { count (1); return (PARSEOP_INCLUDE); } "Include" { count (1); return (PARSEOP_INCLUDE); }
"#include" { count (1); return (PARSEOP_INCLUDE_CSTYLE); }
"#line" { count (1); return (PARSEOP_LINE_CSTYLE); }
"External" { count (1); return (PARSEOP_EXTERNAL); } "External" { count (1); return (PARSEOP_EXTERNAL); }
/*
* The #line directive is emitted by the preprocessor and handled
* here in the main iASL lexer - simply set the line number and
* optionally the current filename.
*/
"#line" { AslDoLineDirective ();}
/**************************************************************************** /****************************************************************************
* *
* Main ASL operators * Main ASL operators
@ -634,668 +646,7 @@ NamePathTail [.]{NameSeg}
/*! [End] no source code translation !*/ /*! [End] no source code translation !*/
typedef struct asl_file_node /*
{ * Bring in the scanner support routines
FILE *File; */
UINT32 CurrentLineNumber; #include <contrib/dev/acpica/compiler/aslsupport.l>
YY_BUFFER_STATE State;
char *Filename;
struct asl_file_node *Next;
} ASL_FILE_NODE;
ASL_FILE_NODE *InputStack = NULL;
/*******************************************************************************
*
* 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
AslPopInputFileStack (
void)
{
ASL_FILE_NODE *Fnode;
Fnode = InputStack;
DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
if (!Fnode)
{
return -1;
}
/* Close the current include file */
fclose (yyin);
/* Update the top-of-stack */
InputStack = Fnode->Next;
/* Reset global line counter and filename */
Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
/* Point the parser to the popped file */
yy_delete_buffer (YY_CURRENT_BUFFER);
yy_switch_to_buffer (Fnode->State);
/* All done with this node */
ACPI_FREE (Fnode);
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
AslPushInputFileStack (
FILE *InputFile,
char *Filename)
{
ASL_FILE_NODE *Fnode;
YY_BUFFER_STATE State;
/* Save the current state in an Fnode */
Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
Fnode->File = yyin;
Fnode->Next = InputStack;
Fnode->State = YY_CURRENT_BUFFER;
Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
/* Push it on the stack */
InputStack = Fnode;
/* Point the parser to this file */
State = yy_create_buffer (InputFile, YY_BUF_SIZE);
yy_switch_to_buffer (State);
DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
/* Reset the global line count and filename */
Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
Gbl_CurrentLineNumber = 1;
yyin = InputFile;
}
/*******************************************************************************
*
* FUNCTION: ResetCurrentLineBuffer
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
*
******************************************************************************/
void
ResetCurrentLineBuffer (
void)
{
if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
{
FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
}
Gbl_CurrentLineOffset += Gbl_CurrentColumn;
Gbl_CurrentColumn = 0;
Gbl_CurrentLineNumber++;
Gbl_LogicalLineNumber++;
Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
}
/*******************************************************************************
*
* FUNCTION: InsertLineBuffer
*
* 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
*
******************************************************************************/
#define ASL_SPACES_PER_TAB 4
void
InsertLineBuffer (
int SourceChar)
{
UINT32 i;
UINT32 Count = 1;
if (SourceChar == EOF)
{
return;
}
Gbl_InputByteCount++;
/* Handle tabs. Convert to spaces */
if (SourceChar == '\t')
{
SourceChar = ' ';
Count = ASL_SPACES_PER_TAB -
(Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
}
for (i = 0; i < Count; i++)
{
Gbl_CurrentColumn++;
/* Insert the character into the line buffer */
*Gbl_LineBufPtr = (UINT8) SourceChar;
Gbl_LineBufPtr++;
if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1)))
{
#if 0
/*
* Warning if we have split a long source line.
* <Probably overkill>
*/
sprintf (MsgBuffer, "Max %u", ASL_LINE_BUFFER_SIZE);
AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
#endif
ResetCurrentLineBuffer ();
}
else if (SourceChar == '\n')
{
/* End of line */
ResetCurrentLineBuffer ();
}
}
}
/*******************************************************************************
*
* FUNCTION: count
*
* PARAMETERS: yytext - Contains the matched keyword.
* Type - Keyword/Character type:
* 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
*
******************************************************************************/
void
count (
int Type)
{
int i;
switch (Type)
{
case 2:
TotalKeywords++;
TotalNamedObjects++;
break;
case 3:
TotalKeywords++;
TotalExecutableOpcodes++;
break;
}
for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
{
InsertLineBuffer (yytext[i]);
*Gbl_LineBufPtr = 0;
}
}
/*******************************************************************************
*
* FUNCTION: comment
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Process a standard comment.
*
******************************************************************************/
char
comment (void)
{
char c;
char c1 = 0;
InsertLineBuffer ('/');
InsertLineBuffer ('*');
loop:
/* Eat chars until end-of-comment */
while ((c = (char) input()) != '*' && c != EOF)
{
InsertLineBuffer (c);
c1 = c;
}
if (c == EOF)
{
goto EarlyEOF;
}
/*
* Check for nested comment -- can help catch cases where a previous
* comment was accidently left unterminated
*/
if ((c1 == '/') && (c == '*'))
{
AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_InputByteCount, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
}
/* Comment is closed only if the NEXT character is a slash */
InsertLineBuffer (c);
if ((c1 = (char) input()) != '/' && c1 != EOF)
{
unput(c1);
goto loop;
}
if (c1 == EOF)
{
goto EarlyEOF;
}
InsertLineBuffer (c1);
return TRUE;
EarlyEOF:
/*
* Premature End-Of-File
*/
AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
return (FALSE);
}
/*******************************************************************************
*
* FUNCTION: comment
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Process a new "//" comment.
*
******************************************************************************/
char
comment2 (void)
{
char c;
InsertLineBuffer ('/');
InsertLineBuffer ('/');
while ((c = (char) input()) != '\n' && c != EOF)
{
InsertLineBuffer (c);
}
if (c == EOF)
{
/* End of file is OK, change to newline. Let parser detect EOF later */
c = '\n';
}
InsertLineBuffer (c);
return (TRUE);
}
/*******************************************************************************
*
* FUNCTION: literal
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Process a string literal (surrounded by quotes)
*
******************************************************************************/
#define ASL_NORMAL_CHAR 0
#define ASL_ESCAPE_SEQUENCE 1
#define ASL_OCTAL_CONSTANT 2
#define ASL_HEX_CONSTANT 3
char
literal (void)
{
char *StringBuffer = MsgBuffer;
char *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
char *CleanString;
char StringChar;
UINT32 State = ASL_NORMAL_CHAR;
UINT32 i = 0;
UINT8 Digit;
char ConvertBuffer[4];
/*
* Eat chars until end-of-literal.
* NOTE: Put back the original surrounding quotes into the
* source line buffer.
*/
InsertLineBuffer ('\"');
while ((StringChar = (char) input()) != EOF)
{
InsertLineBuffer (StringChar);
DoCharacter:
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).
*/
State = ASL_ESCAPE_SEQUENCE;
continue;
case '\"':
/* String terminator */
goto CompletedString;
}
break;
case ASL_ESCAPE_SEQUENCE:
State = ASL_NORMAL_CHAR;
switch (StringChar)
{
case 'a':
StringChar = 0x07; /* BELL */
break;
case 'b':
StringChar = 0x08; /* BACKSPACE */
break;
case 'f':
StringChar = 0x0C; /* FORMFEED */
break;
case 'n':
StringChar = 0x0A; /* LINEFEED */
break;
case 'r':
StringChar = 0x0D; /* CARRIAGE RETURN*/
break;
case 't':
StringChar = 0x09; /* HORIZONTAL TAB */
break;
case 'v':
StringChar = 0x0B; /* VERTICAL TAB */
break;
case 'x':
State = ASL_HEX_CONSTANT;
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))
{
State = ASL_OCTAL_CONSTANT;
ConvertBuffer[0] = StringChar;
i = 1;
continue;
}
/* Unknown escape sequence issue warning, but use the character */
AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
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;
Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
/* Check for NULL or non-ascii character (ignore if so) */
if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
{
AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
}
else
{
*StringBuffer = (char) Digit;
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
State = ASL_NORMAL_CHAR;
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 (!ACPI_IS_XDIGIT (StringChar) ||
(i > 1))
{
/*
* Reached end of the constant. Convert the assembled ASCII
* string and resume processing of the next character
*/
ConvertBuffer[i] = 0;
Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
/* Check for NULL or non-ascii character (ignore if so) */
if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
{
AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
}
else
{
*StringBuffer = (char) Digit;
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
State = ASL_NORMAL_CHAR;
goto DoCharacter;
break;
}
/* Append another digit of the constant */
ConvertBuffer[i] = StringChar;
i++;
continue;
}
/* Save the finished character */
*StringBuffer = StringChar;
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
/*
* Premature End-Of-File
*/
AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
return (FALSE);
CompletedString:
/*
* Null terminate the input string and copy string to a new buffer
*/
*StringBuffer = 0;
CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
if (!CleanString)
{
AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
return (FALSE);
}
ACPI_STRCPY (CleanString, MsgBuffer);
AslCompilerlval.s = CleanString;
return (TRUE);
BufferOverflow:
/* Literal was too long */
AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");
return (FALSE);
}

224
sys/contrib/dev/acpica/compiler/aslcompiler.y
View File

@ -236,7 +236,6 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_I2C_SERIALBUS %token <i> PARSEOP_I2C_SERIALBUS
%token <i> PARSEOP_IF %token <i> PARSEOP_IF
%token <i> PARSEOP_INCLUDE %token <i> PARSEOP_INCLUDE
%token <i> PARSEOP_INCLUDE_CSTYLE
%token <i> PARSEOP_INCLUDE_END %token <i> PARSEOP_INCLUDE_END
%token <i> PARSEOP_INCREMENT %token <i> PARSEOP_INCREMENT
%token <i> PARSEOP_INDEX %token <i> PARSEOP_INDEX
@ -261,7 +260,6 @@ void * AslLocalAllocate (unsigned int Size);
%token <i> PARSEOP_LEQUAL %token <i> PARSEOP_LEQUAL
%token <i> PARSEOP_LGREATER %token <i> PARSEOP_LGREATER
%token <i> PARSEOP_LGREATEREQUAL %token <i> PARSEOP_LGREATEREQUAL
%token <i> PARSEOP_LINE_CSTYLE
%token <i> PARSEOP_LLESS %token <i> PARSEOP_LLESS
%token <i> PARSEOP_LLESSEQUAL %token <i> PARSEOP_LLESSEQUAL
%token <i> PARSEOP_LNOT %token <i> PARSEOP_LNOT
@ -504,9 +502,7 @@ void * AslLocalAllocate (unsigned int Size);
%type <n> FieldUnit %type <n> FieldUnit
%type <n> FieldUnitEntry %type <n> FieldUnitEntry
%type <n> FieldUnitList %type <n> FieldUnitList
%type <n> IncludeCStyleTerm
%type <n> IncludeTerm %type <n> IncludeTerm
%type <n> LineTerm
%type <n> OffsetTerm %type <n> OffsetTerm
%type <n> OptionalAccessAttribTerm %type <n> OptionalAccessAttribTerm
@ -805,14 +801,18 @@ void * AslLocalAllocate (unsigned int Size);
/* /*
* Blocks, Data, and Opcodes * Root rule. Allow multiple #line directives before the definition block
* to handle output from preprocessors
*/ */
ASLCode ASLCode
: DefinitionBlockTerm : DefinitionBlockTerm
| error {YYABORT; $$ = NULL;} | error {YYABORT; $$ = NULL;}
; ;
/*
* Blocks, Data, and Opcodes
*/
/* /*
* Note concerning support for "module-level code". * Note concerning support for "module-level code".
* *
@ -829,7 +829,7 @@ ASLCode
* of Type1 and Type2 opcodes at module level. * of Type1 and Type2 opcodes at module level.
*/ */
DefinitionBlockTerm DefinitionBlockTerm
: PARSEOP_DEFINITIONBLOCK '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITIONBLOCK);} : PARSEOP_DEFINITIONBLOCK '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFINITIONBLOCK);}
String ',' String ','
String ',' String ','
ByteConst ',' ByteConst ','
@ -863,8 +863,6 @@ Term
CompilerDirective CompilerDirective
: IncludeTerm {} : IncludeTerm {}
| IncludeCStyleTerm {$$ = NULL;}
| LineTerm {$$ = NULL;}
| ExternalTerm {} | ExternalTerm {}
; ;
@ -1148,26 +1146,16 @@ Type6Opcode
; ;
IncludeTerm IncludeTerm
: PARSEOP_INCLUDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCLUDE);} : PARSEOP_INCLUDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCLUDE);}
String ')' {TrLinkChildren ($<n>3,1,$4);FlOpenIncludeFile ($4);} String ')' {TrLinkChildren ($<n>3,1,$4);FlOpenIncludeFile ($4);}
TermList TermList
IncludeEndTerm {$$ = TrLinkPeerNodes (3,$<n>3,$7,$8);} IncludeEndTerm {$$ = TrLinkPeerNodes (3,$<n>3,$7,$8);}
; ;
IncludeEndTerm IncludeEndTerm
: PARSEOP_INCLUDE_END {$$ = TrCreateLeafNode (PARSEOP_INCLUDE_END);} : PARSEOP_INCLUDE_END {$$ = TrCreateLeafNode (PARSEOP_INCLUDE_END);}
; ;
IncludeCStyleTerm
: PARSEOP_INCLUDE_CSTYLE
String {FlOpenIncludeFile ($2);}
;
LineTerm
: PARSEOP_LINE_CSTYLE
Integer {FlSetLineNumber ($2);}
;
ExternalTerm ExternalTerm
: PARSEOP_EXTERNAL '(' : PARSEOP_EXTERNAL '('
NameString NameString
@ -1184,7 +1172,7 @@ ExternalTerm
BankFieldTerm BankFieldTerm
: PARSEOP_BANKFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BANKFIELD);} : PARSEOP_BANKFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_BANKFIELD);}
NameString NameString
NameStringItem NameStringItem
TermArgItem TermArgItem
@ -1251,7 +1239,7 @@ ConnectionTerm
; ;
CreateBitFieldTerm CreateBitFieldTerm
: PARSEOP_CREATEBITFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);} : PARSEOP_CREATEBITFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBITFIELD);}
TermArg TermArg
TermArgItem TermArgItem
NameStringItem NameStringItem
@ -1261,7 +1249,7 @@ CreateBitFieldTerm
; ;
CreateByteFieldTerm CreateByteFieldTerm
: PARSEOP_CREATEBYTEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);} : PARSEOP_CREATEBYTEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEBYTEFIELD);}
TermArg TermArg
TermArgItem TermArgItem
NameStringItem NameStringItem
@ -1271,7 +1259,7 @@ CreateByteFieldTerm
; ;
CreateDWordFieldTerm CreateDWordFieldTerm
: PARSEOP_CREATEDWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);} : PARSEOP_CREATEDWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEDWORDFIELD);}
TermArg TermArg
TermArgItem TermArgItem
NameStringItem NameStringItem
@ -1281,7 +1269,7 @@ CreateDWordFieldTerm
; ;
CreateFieldTerm CreateFieldTerm
: PARSEOP_CREATEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);} : PARSEOP_CREATEFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEFIELD);}
TermArg TermArg
TermArgItem TermArgItem
TermArgItem TermArgItem
@ -1292,7 +1280,7 @@ CreateFieldTerm
; ;
CreateQWordFieldTerm CreateQWordFieldTerm
: PARSEOP_CREATEQWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);} : PARSEOP_CREATEQWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEQWORDFIELD);}
TermArg TermArg
TermArgItem TermArgItem
NameStringItem NameStringItem
@ -1302,7 +1290,7 @@ CreateQWordFieldTerm
; ;
CreateWordFieldTerm CreateWordFieldTerm
: PARSEOP_CREATEWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);} : PARSEOP_CREATEWORDFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CREATEWORDFIELD);}
TermArg TermArg
TermArgItem TermArgItem
NameStringItem NameStringItem
@ -1312,7 +1300,7 @@ CreateWordFieldTerm
; ;
DataRegionTerm DataRegionTerm
: PARSEOP_DATATABLEREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);} : PARSEOP_DATATABLEREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DATATABLEREGION);}
NameString NameString
TermArgItem TermArgItem
TermArgItem TermArgItem
@ -1323,7 +1311,7 @@ DataRegionTerm
; ;
DeviceTerm DeviceTerm
: PARSEOP_DEVICE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEVICE);} : PARSEOP_DEVICE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEVICE);}
NameString NameString
')' '{' ')' '{'
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);} ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
@ -1332,7 +1320,7 @@ DeviceTerm
; ;
EventTerm EventTerm
: PARSEOP_EVENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EVENT);} : PARSEOP_EVENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_EVENT);}
NameString NameString
')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));} ')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION));}
| PARSEOP_EVENT '(' | PARSEOP_EVENT '('
@ -1340,7 +1328,7 @@ EventTerm
; ;
FieldTerm FieldTerm
: PARSEOP_FIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIELD);} : PARSEOP_FIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FIELD);}
NameString NameString
',' AccessTypeKeyword ',' AccessTypeKeyword
',' LockRuleKeyword ',' LockRuleKeyword
@ -1352,7 +1340,7 @@ FieldTerm
; ;
FunctionTerm FunctionTerm
: PARSEOP_FUNCTION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);} : PARSEOP_FUNCTION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
NameString NameString
OptionalParameterTypePackage OptionalParameterTypePackage
OptionalParameterTypesPackage OptionalParameterTypesPackage
@ -1366,7 +1354,7 @@ FunctionTerm
; ;
IndexFieldTerm IndexFieldTerm
: PARSEOP_INDEXFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);} : PARSEOP_INDEXFIELD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEXFIELD);}
NameString NameString
NameStringItem NameStringItem
',' AccessTypeKeyword ',' AccessTypeKeyword
@ -1379,7 +1367,7 @@ IndexFieldTerm
; ;
MethodTerm MethodTerm
: PARSEOP_METHOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);} : PARSEOP_METHOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_METHOD);}
NameString NameString
OptionalByteConstExpr {UtCheckIntegerRange ($5, 0, 7);} OptionalByteConstExpr {UtCheckIntegerRange ($5, 0, 7);}
OptionalSerializeRuleKeyword OptionalSerializeRuleKeyword
@ -1393,7 +1381,7 @@ MethodTerm
; ;
MutexTerm MutexTerm
: PARSEOP_MUTEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MUTEX);} : PARSEOP_MUTEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MUTEX);}
NameString NameString
',' ByteConstExpr ',' ByteConstExpr
')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);} ')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
@ -1402,7 +1390,7 @@ MutexTerm
; ;
OpRegionTerm OpRegionTerm
: PARSEOP_OPERATIONREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);} : PARSEOP_OPERATIONREGION '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OPERATIONREGION);}
NameString NameString
',' OpRegionSpaceIdTerm ',' OpRegionSpaceIdTerm
TermArgItem TermArgItem
@ -1418,7 +1406,7 @@ OpRegionSpaceIdTerm
; ;
PowerResTerm PowerResTerm
: PARSEOP_POWERRESOURCE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);} : PARSEOP_POWERRESOURCE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_POWERRESOURCE);}
NameString NameString
',' ByteConstExpr ',' ByteConstExpr
',' WordConstExpr ',' WordConstExpr
@ -1429,7 +1417,7 @@ PowerResTerm
; ;
ProcessorTerm ProcessorTerm
: PARSEOP_PROCESSOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_PROCESSOR);} : PARSEOP_PROCESSOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_PROCESSOR);}
NameString NameString
',' ByteConstExpr ',' ByteConstExpr
OptionalDWordConstExpr OptionalDWordConstExpr
@ -1441,7 +1429,7 @@ ProcessorTerm
; ;
ThermalZoneTerm ThermalZoneTerm
: PARSEOP_THERMALZONE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_THERMALZONE);} : PARSEOP_THERMALZONE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_THERMALZONE);}
NameString NameString
')' '{' ')' '{'
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);} ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
@ -1454,7 +1442,7 @@ ThermalZoneTerm
AliasTerm AliasTerm
: PARSEOP_ALIAS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ALIAS);} : PARSEOP_ALIAS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ALIAS);}
NameString NameString
NameStringItem NameStringItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));} ')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($5, NODE_IS_NAME_DECLARATION));}
@ -1463,7 +1451,7 @@ AliasTerm
; ;
NameTerm NameTerm
: PARSEOP_NAME '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAME);} : PARSEOP_NAME '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAME);}
NameString NameString
',' DataObject ',' DataObject
')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);} ')' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$6);}
@ -1472,7 +1460,7 @@ NameTerm
; ;
ScopeTerm ScopeTerm
: PARSEOP_SCOPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SCOPE);} : PARSEOP_SCOPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SCOPE);}
NameString NameString
')' '{' ')' '{'
ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);} ObjectList '}' {$$ = TrLinkChildren ($<n>3,2,TrSetNodeFlags ($4, NODE_IS_NAME_DECLARATION),$7);}
@ -1485,19 +1473,19 @@ ScopeTerm
BreakTerm BreakTerm
: PARSEOP_BREAK {$$ = TrCreateNode (PARSEOP_BREAK, 0);} : PARSEOP_BREAK {$$ = TrCreateNode (PARSEOP_BREAK, 0);}
; ;
BreakPointTerm BreakPointTerm
: PARSEOP_BREAKPOINT {$$ = TrCreateNode (PARSEOP_BREAKPOINT, 0);} : PARSEOP_BREAKPOINT {$$ = TrCreateNode (PARSEOP_BREAKPOINT, 0);}
; ;
ContinueTerm ContinueTerm
: PARSEOP_CONTINUE {$$ = TrCreateNode (PARSEOP_CONTINUE, 0);} : PARSEOP_CONTINUE {$$ = TrCreateNode (PARSEOP_CONTINUE, 0);}
; ;
FatalTerm FatalTerm
: PARSEOP_FATAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FATAL);} : PARSEOP_FATAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FATAL);}
ByteConstExpr ByteConstExpr
',' DWordConstExpr ',' DWordConstExpr
TermArgItem TermArgItem
@ -1511,7 +1499,7 @@ IfElseTerm
; ;
IfTerm IfTerm
: PARSEOP_IF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IF);} : PARSEOP_IF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
TermArg TermArg
')' '{' ')' '{'
TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
@ -1522,7 +1510,7 @@ IfTerm
ElseTerm ElseTerm
: {$$ = NULL;} : {$$ = NULL;}
| PARSEOP_ELSE '{' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);} | PARSEOP_ELSE '{' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);} TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_ELSE '{' | PARSEOP_ELSE '{'
@ -1531,10 +1519,10 @@ ElseTerm
| PARSEOP_ELSE | PARSEOP_ELSE
error {$$ = AslDoError(); yyclearin;} error {$$ = AslDoError(); yyclearin;}
| PARSEOP_ELSEIF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);} | PARSEOP_ELSEIF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ELSE);}
TermArg {$<n>$ = TrCreateLeafNode (PARSEOP_IF);} TermArg {$<n>$ = TrCreateLeafNode (PARSEOP_IF);}
')' '{' ')' '{'
TermList '}' {TrLinkChildren ($<n>5,2,$4,$8);} TermList '}' {TrLinkChildren ($<n>5,2,$4,$8);}
ElseTerm {TrLinkPeerNode ($<n>5,$11);} ElseTerm {TrLinkPeerNode ($<n>5,$11);}
{$$ = TrLinkChildren ($<n>3,1,$<n>5);} {$$ = TrLinkChildren ($<n>3,1,$<n>5);}
@ -1546,7 +1534,7 @@ ElseTerm
; ;
LoadTerm LoadTerm
: PARSEOP_LOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOAD);} : PARSEOP_LOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOAD);}
NameString NameString
RequiredTarget RequiredTarget
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1555,11 +1543,11 @@ LoadTerm
; ;
NoOpTerm NoOpTerm
: PARSEOP_NOOP {$$ = TrCreateNode (PARSEOP_NOOP, 0);} : PARSEOP_NOOP {$$ = TrCreateNode (PARSEOP_NOOP, 0);}
; ;
NotifyTerm NotifyTerm
: PARSEOP_NOTIFY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOTIFY);} : PARSEOP_NOTIFY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOTIFY);}
SuperName SuperName
TermArgItem TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1568,7 +1556,7 @@ NotifyTerm
; ;
ReleaseTerm ReleaseTerm
: PARSEOP_RELEASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RELEASE);} : PARSEOP_RELEASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RELEASE);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_RELEASE '(' | PARSEOP_RELEASE '('
@ -1576,7 +1564,7 @@ ReleaseTerm
; ;
ResetTerm ResetTerm
: PARSEOP_RESET '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RESET);} : PARSEOP_RESET '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RESET);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_RESET '(' | PARSEOP_RESET '('
@ -1584,16 +1572,16 @@ ResetTerm
; ;
ReturnTerm ReturnTerm
: PARSEOP_RETURN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RETURN);} : PARSEOP_RETURN '(' {$<n>$ = TrCreateLeafNode (PARSEOP_RETURN);}
OptionalReturnArg OptionalReturnArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_RETURN {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_RETURN),1,TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN));} | PARSEOP_RETURN {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_RETURN),1,TrSetNodeFlags (TrCreateLeafNode (PARSEOP_ZERO), NODE_IS_NULL_RETURN));}
| PARSEOP_RETURN '(' | PARSEOP_RETURN '('
error ')' {$$ = AslDoError(); yyclearin;} error ')' {$$ = AslDoError(); yyclearin;}
; ;
SignalTerm SignalTerm
: PARSEOP_SIGNAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIGNAL);} : PARSEOP_SIGNAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIGNAL);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_SIGNAL '(' | PARSEOP_SIGNAL '('
@ -1601,7 +1589,7 @@ SignalTerm
; ;
SleepTerm SleepTerm
: PARSEOP_SLEEP '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SLEEP);} : PARSEOP_SLEEP '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SLEEP);}
TermArg TermArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_SLEEP '(' | PARSEOP_SLEEP '('
@ -1609,7 +1597,7 @@ SleepTerm
; ;
StallTerm StallTerm
: PARSEOP_STALL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STALL);} : PARSEOP_STALL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STALL);}
TermArg TermArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_STALL '(' | PARSEOP_STALL '('
@ -1617,7 +1605,7 @@ StallTerm
; ;
SwitchTerm SwitchTerm
: PARSEOP_SWITCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SWITCH);} : PARSEOP_SWITCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SWITCH);}
TermArg TermArg
')' '{' ')' '{'
CaseDefaultTermList '}' CaseDefaultTermList '}'
@ -1660,7 +1648,7 @@ CaseTermList
*/ */
CaseTerm CaseTerm
: PARSEOP_CASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CASE);} : PARSEOP_CASE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CASE);}
DataObject DataObject
')' '{' ')' '{'
TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);} TermList '}' {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
@ -1669,14 +1657,14 @@ CaseTerm
; ;
DefaultTerm DefaultTerm
: PARSEOP_DEFAULT '{' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFAULT);} : PARSEOP_DEFAULT '{' {$<n>$ = TrCreateLeafNode (PARSEOP_DEFAULT);}
TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);} TermList '}' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_DEFAULT '{' | PARSEOP_DEFAULT '{'
error '}' {$$ = AslDoError(); yyclearin;} error '}' {$$ = AslDoError(); yyclearin;}
; ;
UnloadTerm UnloadTerm
: PARSEOP_UNLOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNLOAD);} : PARSEOP_UNLOAD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_UNLOAD);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_UNLOAD '(' | PARSEOP_UNLOAD '('
@ -1684,7 +1672,7 @@ UnloadTerm
; ;
WhileTerm WhileTerm
: PARSEOP_WHILE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WHILE);} : PARSEOP_WHILE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WHILE);}
TermArg TermArg
')' '{' TermList '}' ')' '{' TermList '}'
{$$ = TrLinkChildren ($<n>3,2,$4,$7);} {$$ = TrLinkChildren ($<n>3,2,$4,$7);}
@ -1696,7 +1684,7 @@ WhileTerm
/******* Type 2 opcodes *******************************************************/ /******* Type 2 opcodes *******************************************************/
AcquireTerm AcquireTerm
: PARSEOP_ACQUIRE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACQUIRE);} : PARSEOP_ACQUIRE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ACQUIRE);}
SuperName SuperName
',' WordConstExpr ',' WordConstExpr
')' {$$ = TrLinkChildren ($<n>3,2,$4,$6);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$6);}
@ -1705,7 +1693,7 @@ AcquireTerm
; ;
AddTerm AddTerm
: PARSEOP_ADD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);} : PARSEOP_ADD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_ADD);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1715,7 +1703,7 @@ AddTerm
; ;
AndTerm AndTerm
: PARSEOP_AND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_AND);} : PARSEOP_AND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_AND);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1725,7 +1713,7 @@ AndTerm
; ;
ConcatTerm ConcatTerm
: PARSEOP_CONCATENATE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATE);} : PARSEOP_CONCATENATE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONCATENATE);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1745,7 +1733,7 @@ ConcatResTerm
; ;
CondRefOfTerm CondRefOfTerm
: PARSEOP_CONDREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONDREFOF);} : PARSEOP_CONDREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_CONDREFOF);}
SuperName SuperName
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1754,7 +1742,7 @@ CondRefOfTerm
; ;
CopyObjectTerm CopyObjectTerm
: PARSEOP_COPYOBJECT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);} : PARSEOP_COPYOBJECT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_COPYOBJECT);}
TermArg TermArg
',' SimpleTarget ',' SimpleTarget
')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));} ')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
@ -1763,7 +1751,7 @@ CopyObjectTerm
; ;
DecTerm DecTerm
: PARSEOP_DECREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DECREMENT);} : PARSEOP_DECREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DECREMENT);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_DECREMENT '(' | PARSEOP_DECREMENT '('
@ -1771,7 +1759,7 @@ DecTerm
; ;
DerefOfTerm DerefOfTerm
: PARSEOP_DEREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEREFOF);} : PARSEOP_DEREFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DEREFOF);}
TermArg TermArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_DEREFOF '(' | PARSEOP_DEREFOF '('
@ -1779,7 +1767,7 @@ DerefOfTerm
; ;
DivideTerm DivideTerm
: PARSEOP_DIVIDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DIVIDE);} : PARSEOP_DIVIDE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_DIVIDE);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1790,7 +1778,7 @@ DivideTerm
; ;
FindSetLeftBitTerm FindSetLeftBitTerm
: PARSEOP_FINDSETLEFTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);} : PARSEOP_FINDSETLEFTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETLEFTBIT);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1799,7 +1787,7 @@ FindSetLeftBitTerm
; ;
FindSetRightBitTerm FindSetRightBitTerm
: PARSEOP_FINDSETRIGHTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);} : PARSEOP_FINDSETRIGHTBIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FINDSETRIGHTBIT);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1808,7 +1796,7 @@ FindSetRightBitTerm
; ;
FromBCDTerm FromBCDTerm
: PARSEOP_FROMBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FROMBCD);} : PARSEOP_FROMBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_FROMBCD);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1817,7 +1805,7 @@ FromBCDTerm
; ;
IncTerm IncTerm
: PARSEOP_INCREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCREMENT);} : PARSEOP_INCREMENT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INCREMENT);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_INCREMENT '(' | PARSEOP_INCREMENT '('
@ -1825,7 +1813,7 @@ IncTerm
; ;
IndexTerm IndexTerm
: PARSEOP_INDEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEX);} : PARSEOP_INDEX '(' {$<n>$ = TrCreateLeafNode (PARSEOP_INDEX);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1835,7 +1823,7 @@ IndexTerm
; ;
LAndTerm LAndTerm
: PARSEOP_LAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LAND);} : PARSEOP_LAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LAND);}
TermArg TermArg
TermArgItem TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1844,7 +1832,7 @@ LAndTerm
; ;
LEqualTerm LEqualTerm
: PARSEOP_LEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);} : PARSEOP_LEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
TermArg TermArg
TermArgItem TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1853,7 +1841,7 @@ LEqualTerm
; ;
LGreaterTerm LGreaterTerm
: PARSEOP_LGREATER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);} : PARSEOP_LGREATER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
TermArg TermArg
TermArgItem TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1862,7 +1850,7 @@ LGreaterTerm
; ;
LGreaterEqualTerm LGreaterEqualTerm
: PARSEOP_LGREATEREQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);} : PARSEOP_LGREATEREQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
TermArg TermArg
TermArgItem TermArgItem
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));} ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
@ -1871,7 +1859,7 @@ LGreaterEqualTerm
; ;
LLessTerm LLessTerm
: PARSEOP_LLESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);} : PARSEOP_LLESS '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LLESS);}
TermArg TermArg
TermArgItem TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1880,7 +1868,7 @@ LLessTerm
; ;
LLessEqualTerm LLessEqualTerm
: PARSEOP_LLESSEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);} : PARSEOP_LLESSEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LGREATER);}
TermArg TermArg
TermArgItem TermArgItem
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));} ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
@ -1889,7 +1877,7 @@ LLessEqualTerm
; ;
LNotTerm LNotTerm
: PARSEOP_LNOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LNOT);} : PARSEOP_LNOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LNOT);}
TermArg TermArg
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_LNOT '(' | PARSEOP_LNOT '('
@ -1897,7 +1885,7 @@ LNotTerm
; ;
LNotEqualTerm LNotEqualTerm
: PARSEOP_LNOTEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);} : PARSEOP_LNOTEQUAL '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LEQUAL);}
TermArg TermArg
TermArgItem TermArgItem
')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));} ')' {$$ = TrCreateNode (PARSEOP_LNOT, 1, TrLinkChildren ($<n>3,2,$4,$5));}
@ -1906,7 +1894,7 @@ LNotEqualTerm
; ;
LoadTableTerm LoadTableTerm
: PARSEOP_LOADTABLE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOADTABLE);} : PARSEOP_LOADTABLE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOADTABLE);}
TermArg TermArg
TermArgItem TermArgItem
TermArgItem TermArgItem
@ -1919,7 +1907,7 @@ LoadTableTerm
; ;
LOrTerm LOrTerm
: PARSEOP_LOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOR);} : PARSEOP_LOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_LOR);}
TermArg TermArg
TermArgItem TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -1928,7 +1916,7 @@ LOrTerm
; ;
MatchTerm MatchTerm
: PARSEOP_MATCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MATCH);} : PARSEOP_MATCH '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MATCH);}
TermArg TermArg
',' MatchOpKeyword ',' MatchOpKeyword
TermArgItem TermArgItem
@ -1941,7 +1929,7 @@ MatchTerm
; ;
MidTerm MidTerm
: PARSEOP_MID '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MID);} : PARSEOP_MID '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MID);}
TermArg TermArg
TermArgItem TermArgItem
TermArgItem TermArgItem
@ -1952,7 +1940,7 @@ MidTerm
; ;
ModTerm ModTerm
: PARSEOP_MOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MOD);} : PARSEOP_MOD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MOD);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1962,7 +1950,7 @@ ModTerm
; ;
MultiplyTerm MultiplyTerm
: PARSEOP_MULTIPLY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MULTIPLY);} : PARSEOP_MULTIPLY '(' {$<n>$ = TrCreateLeafNode (PARSEOP_MULTIPLY);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1972,7 +1960,7 @@ MultiplyTerm
; ;
NAndTerm NAndTerm
: PARSEOP_NAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAND);} : PARSEOP_NAND '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NAND);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1982,7 +1970,7 @@ NAndTerm
; ;
NOrTerm NOrTerm
: PARSEOP_NOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOR);} : PARSEOP_NOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOR);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -1992,7 +1980,7 @@ NOrTerm
; ;
NotTerm NotTerm
: PARSEOP_NOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOT);} : PARSEOP_NOT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_NOT);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -2001,7 +1989,7 @@ NotTerm
; ;
ObjectTypeTerm ObjectTypeTerm
: PARSEOP_OBJECTTYPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);} : PARSEOP_OBJECTTYPE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OBJECTTYPE);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_OBJECTTYPE '(' | PARSEOP_OBJECTTYPE '('
@ -2009,7 +1997,7 @@ ObjectTypeTerm
; ;
OrTerm OrTerm
: PARSEOP_OR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OR);} : PARSEOP_OR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_OR);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -2023,7 +2011,7 @@ OrTerm
* we've taken a pointer to it. (hard to tell if a local becomes initialized this way.) * we've taken a pointer to it. (hard to tell if a local becomes initialized this way.)
*/ */
RefOfTerm RefOfTerm
: PARSEOP_REFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_REFOF);} : PARSEOP_REFOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_REFOF);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));} ')' {$$ = TrLinkChildren ($<n>3,1,TrSetNodeFlags ($4, NODE_IS_TARGET));}
| PARSEOP_REFOF '(' | PARSEOP_REFOF '('
@ -2031,7 +2019,7 @@ RefOfTerm
; ;
ShiftLeftTerm ShiftLeftTerm
: PARSEOP_SHIFTLEFT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);} : PARSEOP_SHIFTLEFT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTLEFT);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -2041,7 +2029,7 @@ ShiftLeftTerm
; ;
ShiftRightTerm ShiftRightTerm
: PARSEOP_SHIFTRIGHT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);} : PARSEOP_SHIFTRIGHT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SHIFTRIGHT);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -2051,7 +2039,7 @@ ShiftRightTerm
; ;
SizeOfTerm SizeOfTerm
: PARSEOP_SIZEOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIZEOF);} : PARSEOP_SIZEOF '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SIZEOF);}
SuperName SuperName
')' {$$ = TrLinkChildren ($<n>3,1,$4);} ')' {$$ = TrLinkChildren ($<n>3,1,$4);}
| PARSEOP_SIZEOF '(' | PARSEOP_SIZEOF '('
@ -2059,7 +2047,7 @@ SizeOfTerm
; ;
StoreTerm StoreTerm
: PARSEOP_STORE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STORE);} : PARSEOP_STORE '(' {$<n>$ = TrCreateLeafNode (PARSEOP_STORE);}
TermArg TermArg
',' SuperName ',' SuperName
')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));} ')' {$$ = TrLinkChildren ($<n>3,2,$4,TrSetNodeFlags ($6, NODE_IS_TARGET));}
@ -2068,7 +2056,7 @@ StoreTerm
; ;
SubtractTerm SubtractTerm
: PARSEOP_SUBTRACT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SUBTRACT);} : PARSEOP_SUBTRACT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_SUBTRACT);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -2078,15 +2066,15 @@ SubtractTerm
; ;
TimerTerm TimerTerm
: PARSEOP_TIMER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TIMER);} : PARSEOP_TIMER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TIMER);}
')' {$$ = TrLinkChildren ($<n>3,0);} ')' {$$ = TrLinkChildren ($<n>3,0);}
| PARSEOP_TIMER {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_TIMER),0);} | PARSEOP_TIMER {$$ = TrLinkChildren (TrCreateLeafNode (PARSEOP_TIMER),0);}
| PARSEOP_TIMER '(' | PARSEOP_TIMER '('
error ')' {$$ = AslDoError(); yyclearin;} error ')' {$$ = AslDoError(); yyclearin;}
; ;
ToBCDTerm ToBCDTerm
: PARSEOP_TOBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBCD);} : PARSEOP_TOBCD '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBCD);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -2095,7 +2083,7 @@ ToBCDTerm
; ;
ToBufferTerm ToBufferTerm
: PARSEOP_TOBUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBUFFER);} : PARSEOP_TOBUFFER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOBUFFER);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -2104,7 +2092,7 @@ ToBufferTerm
; ;
ToDecimalStringTerm ToDecimalStringTerm
: PARSEOP_TODECIMALSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);} : PARSEOP_TODECIMALSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TODECIMALSTRING);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -2113,7 +2101,7 @@ ToDecimalStringTerm
; ;
ToHexStringTerm ToHexStringTerm
: PARSEOP_TOHEXSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);} : PARSEOP_TOHEXSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOHEXSTRING);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -2122,7 +2110,7 @@ ToHexStringTerm
; ;
ToIntegerTerm ToIntegerTerm
: PARSEOP_TOINTEGER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOINTEGER);} : PARSEOP_TOINTEGER '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOINTEGER);}
TermArg TermArg
Target Target
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -2131,7 +2119,7 @@ ToIntegerTerm
; ;
ToStringTerm ToStringTerm
: PARSEOP_TOSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOSTRING);} : PARSEOP_TOSTRING '(' {$<n>$ = TrCreateLeafNode (PARSEOP_TOSTRING);}
TermArg TermArg
OptionalCount OptionalCount
Target Target
@ -2148,7 +2136,7 @@ ToUUIDTerm
; ;
WaitTerm WaitTerm
: PARSEOP_WAIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WAIT);} : PARSEOP_WAIT '(' {$<n>$ = TrCreateLeafNode (PARSEOP_WAIT);}
SuperName SuperName
TermArgItem TermArgItem
')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);} ')' {$$ = TrLinkChildren ($<n>3,2,$4,$5);}
@ -2157,7 +2145,7 @@ WaitTerm
; ;
XOrTerm XOrTerm
: PARSEOP_XOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_XOR);} : PARSEOP_XOR '(' {$<n>$ = TrCreateLeafNode (PARSEOP_XOR);}
TermArg TermArg
TermArgItem TermArgItem
Target Target
@ -2211,8 +2199,8 @@ AddressKeyword
; ;
AddressSpaceKeyword AddressSpaceKeyword
: ByteConst {$$ = UtCheckIntegerRange ($1, 0x80, 0xFF);} : ByteConst {$$ = UtCheckIntegerRange ($1, 0x0A, 0xFF);}
| RegionSpaceKeyword {} | RegionSpaceKeyword {}
; ;
BitsPerByteKeyword BitsPerByteKeyword

21
sys/contrib/dev/acpica/compiler/aslerror.c
View File

@ -259,7 +259,7 @@ AePrintException (
{ {
if (Gbl_VerboseErrors) if (Gbl_VerboseErrors)
{ {
fprintf (OutputFile, "%6s", Enode->Filename); fprintf (OutputFile, "%-8s", Enode->Filename);
if (Enode->LineNumber) if (Enode->LineNumber)
{ {
@ -270,12 +270,7 @@ AePrintException (
} }
else else
{ {
if (Gbl_FileType == ASL_INPUT_TYPE_ASCII_ASL) fprintf (OutputFile, " %6u: ", Enode->LineNumber);
fprintf (OutputFile, " %6u: ",
PrGetLineNumber (Enode->LineNumber));
else
fprintf (OutputFile, " %6u: ",
Enode->LineNumber);
/* /*
* If not at EOF, get the corresponding source code line and * If not at EOF, get the corresponding source code line and
@ -324,16 +319,8 @@ AePrintException (
if (Enode->LineNumber) if (Enode->LineNumber)
{ {
if (Gbl_FileType == ASL_INPUT_TYPE_ASCII_ASL) fprintf (OutputFile, "(%u) i:%6u : ",
{ Enode->LineNumber, Enode->LineNumber);
fprintf (OutputFile, "(%u) i:%6u : ",
PrGetLineNumber (Enode->LineNumber), Enode->LineNumber);
}
else
{
fprintf (OutputFile, "(%u) i:%6u : ",
Enode->LineNumber, Enode->LineNumber);
}
} }
} }
} }

60
sys/contrib/dev/acpica/compiler/aslfiles.c
View File

@ -81,12 +81,12 @@ AslAbort (
void) void)
{ {
AePrintErrorLog (ASL_FILE_STDOUT); AePrintErrorLog (ASL_FILE_STDERR);
if (Gbl_DebugFlag) if (Gbl_DebugFlag)
{ {
/* Print error summary to the debug file */ /* Print error summary to stdout also */
AePrintErrorLog (ASL_FILE_STDERR); AePrintErrorLog (ASL_FILE_STDOUT);
} }
exit (1); exit (1);
@ -388,11 +388,38 @@ FlCloseFile (
void void
FlSetLineNumber ( FlSetLineNumber (
ACPI_PARSE_OBJECT *Op) UINT32 LineNumber)
{ {
Gbl_CurrentLineNumber = (UINT32) Op->Asl.Value.Integer; DbgPrint (ASL_PARSE_OUTPUT, "\n#line: New line number %u (old %u)\n",
Gbl_LogicalLineNumber = (UINT32) Op->Asl.Value.Integer; LineNumber, Gbl_LogicalLineNumber);
Gbl_CurrentLineNumber = LineNumber;
Gbl_LogicalLineNumber = LineNumber;
}
/*******************************************************************************
*
* FUNCTION: FlSetFilename
*
* PARAMETERS: Op - Parse node for the LINE asl statement
*
* RETURN: None.
*
* DESCRIPTION: Set the current filename
*
******************************************************************************/
void
FlSetFilename (
char *Filename)
{
DbgPrint (ASL_PARSE_OUTPUT, "\n#line: New filename %s (old %s)\n",
Filename, Gbl_Files[ASL_FILE_INPUT].Filename);
Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
} }
@ -548,7 +575,7 @@ FlOpenIncludeFile (
* Flush out the "include ()" statement on this line, start * Flush out the "include ()" statement on this line, start
* the actual include file on the next line * the actual include file on the next line
*/ */
ResetCurrentLineBuffer (); AslResetCurrentLineBuffer ();
FlPrintFile (ASL_FILE_SOURCE_OUTPUT, "\n"); FlPrintFile (ASL_FILE_SOURCE_OUTPUT, "\n");
Gbl_CurrentLineOffset++; Gbl_CurrentLineOffset++;
@ -770,17 +797,20 @@ FlOpenMiscOutputFiles (
AslCompilerFileHeader (ASL_FILE_LISTING_OUTPUT); AslCompilerFileHeader (ASL_FILE_LISTING_OUTPUT);
} }
/* Create the preprocessor output file */ /* Create the preprocessor output file if preprocessor enabled */
Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_PREPROCESSOR); if (Gbl_PreprocessFlag)
if (!Filename)
{ {
AslCommonError (ASL_ERROR, ASL_MSG_PREPROCESSOR_FILENAME, Filename = FlGenerateFilename (FilenamePrefix, FILE_SUFFIX_PREPROCESSOR);
0, 0, 0, 0, NULL, NULL); if (!Filename)
return (AE_ERROR); {
} AslCommonError (ASL_ERROR, ASL_MSG_PREPROCESSOR_FILENAME,
0, 0, 0, 0, NULL, NULL);
return (AE_ERROR);
}
FlOpenFile (ASL_FILE_PREPROCESSOR, Filename, "w+b"); FlOpenFile (ASL_FILE_PREPROCESSOR, Filename, "w+b");
}
/* All done for data table compiler */ /* All done for data table compiler */

5
sys/contrib/dev/acpica/compiler/aslglobal.h
View File

@ -74,7 +74,7 @@ extern int PrParserdebug;
extern const ASL_MAPPING_ENTRY AslKeywordMapping[]; extern const ASL_MAPPING_ENTRY AslKeywordMapping[];
extern char *AslCompilertext; extern char *AslCompilertext;
#define ASL_LINE_BUFFER_SIZE 4096 #define ASL_LINE_BUFFER_SIZE (4096 * 4) /* 16K */
#define ASL_MSG_BUFFER_SIZE 4096 #define ASL_MSG_BUFFER_SIZE 4096
#define HEX_TABLE_LINE_SIZE 8 #define HEX_TABLE_LINE_SIZE 8
#define HEX_LISTING_LINE_SIZE 8 #define HEX_LISTING_LINE_SIZE 8
@ -84,6 +84,7 @@ extern char *AslCompilertext;
ASL_EXTERN char Gbl_CurrentLineBuffer[ASL_LINE_BUFFER_SIZE]; ASL_EXTERN char Gbl_CurrentLineBuffer[ASL_LINE_BUFFER_SIZE];
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentColumn, 0); ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentColumn, 0);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_PreviousLineNumber, 0);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentLineNumber, 1); ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentLineNumber, 1);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_LogicalLineNumber, 1); ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_LogicalLineNumber, 1);
ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentLineOffset, 0); ASL_EXTERN UINT32 ASL_INIT_GLOBAL (Gbl_CurrentLineOffset, 0);
@ -99,6 +100,7 @@ ASL_EXTERN ASL_ERROR_MSG ASL_INIT_GLOBAL (*Gbl_NextError,NULL);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DoCompile, TRUE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DoCompile, TRUE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DoSignon, TRUE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DoSignon, TRUE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_PreprocessOnly, FALSE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_PreprocessOnly, FALSE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_PreprocessFlag, TRUE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DisassembleAll, FALSE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DisassembleAll, FALSE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_Acpi2, FALSE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_Acpi2, FALSE);
@ -118,6 +120,7 @@ ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_CompileTimesFlag, FALSE
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_FoldConstants, TRUE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_FoldConstants, TRUE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_VerboseErrors, TRUE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_VerboseErrors, TRUE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_NoErrors, FALSE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_NoErrors, FALSE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_WarningsAsErrors, FALSE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_NoResourceChecking, FALSE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_NoResourceChecking, FALSE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DisasmFlag, FALSE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_DisasmFlag, FALSE);
ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_GetAllTables, FALSE); ASL_EXTERN BOOLEAN ASL_INIT_GLOBAL (Gbl_GetAllTables, FALSE);

27
sys/contrib/dev/acpica/compiler/aslmain.c
View File

@ -96,7 +96,7 @@ AslDoResponseFile (
#define ASL_TOKEN_SEPARATORS " \t\n" #define ASL_TOKEN_SEPARATORS " \t\n"
#define ASL_SUPPORTED_OPTIONS "@:2b|c|d^D:e:fgh^i|I:l^mno|p:Pr:s|t|T:G^v|w|x:z" #define ASL_SUPPORTED_OPTIONS "@:2b|c|d^D:e:fgh^i|I:l^mno|p:P^r:s|t|T:G^v|w|x:z"
/******************************************************************************* /*******************************************************************************
@ -124,6 +124,7 @@ Options (
ACPI_OPTION ("-D <symbol>", "Define symbol for preprocessor use"); ACPI_OPTION ("-D <symbol>", "Define symbol for preprocessor use");
ACPI_OPTION ("-li", "Create preprocessed output file (*.i)"); ACPI_OPTION ("-li", "Create preprocessed output file (*.i)");
ACPI_OPTION ("-P", "Preprocess only and create preprocessor output file (*.i)"); ACPI_OPTION ("-P", "Preprocess only and create preprocessor output file (*.i)");
ACPI_OPTION ("-Pn", "Disable preprocessor");
printf ("\nGeneral Output:\n"); printf ("\nGeneral Output:\n");
ACPI_OPTION ("-p <prefix>", "Specify path/filename prefix for all output files"); ACPI_OPTION ("-p <prefix>", "Specify path/filename prefix for all output files");
@ -133,6 +134,7 @@ Options (
ACPI_OPTION ("-vr", "Disable remarks"); ACPI_OPTION ("-vr", "Disable remarks");
ACPI_OPTION ("-vs", "Disable signon"); ACPI_OPTION ("-vs", "Disable signon");
ACPI_OPTION ("-w1 -w2 -w3", "Set warning reporting level"); ACPI_OPTION ("-w1 -w2 -w3", "Set warning reporting level");
ACPI_OPTION ("-we", "Report warnings as errors");
printf ("\nAML Output Files:\n"); printf ("\nAML Output Files:\n");
ACPI_OPTION ("-sa -sc", "Create AML in assembler or C source file (*.asm or *.c)"); ACPI_OPTION ("-sa -sc", "Create AML in assembler or C source file (*.asm or *.c)");
@ -671,9 +673,22 @@ AslDoOptions (
break; break;
case 'P': /* Preprocess (plus .i file) only */ case 'P': /* Preprocessor options */
Gbl_PreprocessOnly = TRUE; switch (AcpiGbl_Optarg[0])
Gbl_PreprocessorOutputFlag = TRUE; {
case '^': /* Proprocess only, emit (.i) file */
Gbl_PreprocessOnly = TRUE;
Gbl_PreprocessorOutputFlag = TRUE;
break;
case 'n': /* Disable preprocessor */
Gbl_PreprocessFlag = FALSE;
break;
default:
printf ("Unknown option: -P%s\n", AcpiGbl_Optarg);
return (-1);
}
break; break;
@ -793,6 +808,10 @@ AslDoOptions (
Gbl_WarningLevel = ASL_WARNING3; Gbl_WarningLevel = ASL_WARNING3;
break; break;
case 'e':
Gbl_WarningsAsErrors = TRUE;
break;
default: default:
printf ("Unknown option: -w%s\n", AcpiGbl_Optarg); printf ("Unknown option: -w%s\n", AcpiGbl_Optarg);
return (-1); return (-1);

2
sys/contrib/dev/acpica/compiler/aslmap.c
View File

@ -240,7 +240,6 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* I2CSERIALBUS */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0), /* I2CSERIALBUS */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* IF */ OP_TABLE_ENTRY (AML_IF_OP, 0, NODE_AML_PACKAGE, 0), /* IF */ OP_TABLE_ENTRY (AML_IF_OP, 0, NODE_AML_PACKAGE, 0),
/* INCLUDE */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0), /* INCLUDE */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* INCLUDE_CSTYLE */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* INCLUDE_END */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0), /* INCLUDE_END */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* INCREMENT */ OP_TABLE_ENTRY (AML_INCREMENT_OP, 0, 0, ACPI_BTYPE_INTEGER), /* INCREMENT */ OP_TABLE_ENTRY (AML_INCREMENT_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* INDEX */ OP_TABLE_ENTRY (AML_INDEX_OP, 0, 0, ACPI_BTYPE_REFERENCE), /* INDEX */ OP_TABLE_ENTRY (AML_INDEX_OP, 0, 0, ACPI_BTYPE_REFERENCE),
@ -265,7 +264,6 @@ const ASL_MAPPING_ENTRY AslKeywordMapping [] =
/* LEQUAL */ OP_TABLE_ENTRY (AML_LEQUAL_OP, 0, 0, ACPI_BTYPE_INTEGER), /* LEQUAL */ OP_TABLE_ENTRY (AML_LEQUAL_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* LGREATER */ OP_TABLE_ENTRY (AML_LGREATER_OP, 0, 0, ACPI_BTYPE_INTEGER), /* LGREATER */ OP_TABLE_ENTRY (AML_LGREATER_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* LGREATEREQUAL */ OP_TABLE_ENTRY (AML_LGREATEREQUAL_OP, 0, 0, ACPI_BTYPE_INTEGER), /* LGREATEREQUAL */ OP_TABLE_ENTRY (AML_LGREATEREQUAL_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* LINE */ OP_TABLE_ENTRY (AML_DEFAULT_ARG_OP, 0, 0, 0),
/* LLESS */ OP_TABLE_ENTRY (AML_LLESS_OP, 0, 0, ACPI_BTYPE_INTEGER), /* LLESS */ OP_TABLE_ENTRY (AML_LLESS_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* LLESSEQUAL */ OP_TABLE_ENTRY (AML_LLESSEQUAL_OP, 0, 0, ACPI_BTYPE_INTEGER), /* LLESSEQUAL */ OP_TABLE_ENTRY (AML_LLESSEQUAL_OP, 0, 0, ACPI_BTYPE_INTEGER),
/* LNOT */ OP_TABLE_ENTRY (AML_LNOT_OP, 0, 0, ACPI_BTYPE_INTEGER), /* LNOT */ OP_TABLE_ENTRY (AML_LNOT_OP, 0, 0, ACPI_BTYPE_INTEGER),

8
sys/contrib/dev/acpica/compiler/aslrestype1.c
View File

@ -453,6 +453,10 @@ RsDoStartDependentDescriptor (
PreviousRnode = Rnode; PreviousRnode = Rnode;
Descriptor = Rnode->Buffer; Descriptor = Rnode->Buffer;
/* Increment offset past StartDependent descriptor */
CurrentByteOffset += sizeof (AML_RESOURCE_START_DEPENDENT);
/* Descriptor has priority byte */ /* Descriptor has priority byte */
Descriptor->StartDpf.DescriptorType = ACPI_RESOURCE_NAME_START_DEPENDENT | Descriptor->StartDpf.DescriptorType = ACPI_RESOURCE_NAME_START_DEPENDENT |
@ -545,6 +549,10 @@ RsDoStartDependentNoPriDescriptor (
ASL_RDESC_ST_DEPEND_SIZE; ASL_RDESC_ST_DEPEND_SIZE;
PreviousRnode = Rnode; PreviousRnode = Rnode;
/* Increment offset past StartDependentNoPri descriptor */
CurrentByteOffset += sizeof (AML_RESOURCE_START_DEPENDENT_NOPRIO);
/* Process all child initialization nodes */ /* Process all child initialization nodes */
State = ACPI_RSTATE_START_DEPENDENT; State = ACPI_RSTATE_START_DEPENDENT;

76
sys/contrib/dev/acpica/compiler/aslstartup.c
View File

@ -404,18 +404,33 @@ AslDoOneFile (
case ASL_INPUT_TYPE_ASCII_DATA: case ASL_INPUT_TYPE_ASCII_DATA:
Status = DtDoCompile (); Status = DtDoCompile ();
if (ACPI_FAILURE (Status))
{
return (Status);
}
if (Gbl_Signature) if (Gbl_Signature)
{ {
ACPI_FREE (Gbl_Signature); ACPI_FREE (Gbl_Signature);
Gbl_Signature = NULL; Gbl_Signature = NULL;
} }
/* Check if any errors occurred during compile */
Status = AslCheckForErrorExit ();
if (ACPI_FAILURE (Status))
{
return (Status);
}
/* Cleanup (for next source file) and exit */
AeClearErrorLog (); AeClearErrorLog ();
PrTerminatePreprocessor (); PrTerminatePreprocessor ();
return (Status); return (Status);
/* /*
* ASL Compilation (Optional) * ASL Compilation
*/ */
case ASL_INPUT_TYPE_ASCII_ASL: case ASL_INPUT_TYPE_ASCII_ASL:
@ -427,18 +442,19 @@ AslDoOneFile (
return (Status); return (Status);
} }
Status = CmDoCompile (); (void) CmDoCompile ();
(void) AcpiTerminate (); (void) AcpiTerminate ();
/* /* Check if any errors occurred during compile */
* Return non-zero exit code if there have been errors, unless the
* global ignore error flag has been set Status = AslCheckForErrorExit ();
*/ if (ACPI_FAILURE (Status))
if ((Gbl_ExceptionCount[ASL_ERROR] > 0) && (!Gbl_IgnoreErrors))
{ {
return (AE_ERROR); return (Status);
} }
/* Cleanup (for next source file) and exit */
AeClearErrorLog (); AeClearErrorLog ();
PrTerminatePreprocessor (); PrTerminatePreprocessor ();
return (AE_OK); return (AE_OK);
@ -525,3 +541,47 @@ AslDoOnePathname (
return (Status); return (Status);
} }
/*******************************************************************************
*
* FUNCTION: AslCheckForErrorExit
*
* PARAMETERS: None. Examines global exception count array
*
* RETURN: Status
*
* DESCRIPTION: Determine if compiler should abort with error status
*
******************************************************************************/
ACPI_STATUS
AslCheckForErrorExit (
void)
{
/*
* Return non-zero exit code if there have been errors, unless the
* global ignore error flag has been set
*/
if (!Gbl_IgnoreErrors)
{
if (Gbl_ExceptionCount[ASL_ERROR] > 0)
{
return (AE_ERROR);
}
/* Optionally treat warnings as errors */
if (Gbl_WarningsAsErrors)
{
if ((Gbl_ExceptionCount[ASL_WARNING] > 0) ||
(Gbl_ExceptionCount[ASL_WARNING2] > 0) ||
(Gbl_ExceptionCount[ASL_WARNING3] > 0))
{
return (AE_ERROR);
}
}
}
return (AE_OK);
}

782
sys/contrib/dev/acpica/compiler/aslsupport.l Normal file
View File

@ -0,0 +1,782 @@
/******************************************************************************
*
* Module Name: aslsupport.l - Flex/lex scanner C support routines.
* NOTE: Included into aslcompile.l, not compiled by itself.
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2012, 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
{
FILE *File;
UINT32 CurrentLineNumber;
YY_BUFFER_STATE State;
char *Filename;
struct asl_file_node *Next;
} ASL_FILE_NODE;
/* File stack for the "Include" operator (NOT #include operator) */
ASL_FILE_NODE *Gbl_IncludeFileStack = NULL;
/*******************************************************************************
*
* 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
AslDoLineDirective (
void)
{
char c;
char *Token;
UINT32 LineNumber;
char *Filename;
/* Eat the entire line that contains the #line directive */
while ((c = (char) input()) != '\n' && c != EOF)
{
AslInsertLineBuffer (c);
}
AslInsertLineBuffer (0);
/* First argument is the actual line number */
Token = strtok (Gbl_CurrentLineBuffer, " ");
if (!Token)
{
goto ResetAndExit;
}
/* Convert line number. Subtract one to handle _this_ line */
LineNumber = (UINT32) UtDoConstant (Token);
FlSetLineNumber (LineNumber - 1);
/* Second argument is the optional filename (in double quotes) */
Token = strtok (NULL, " \"");
if (Token)
{
Filename = ACPI_ALLOCATE_ZEROED (strlen (Token) + 1);
strcpy (Filename, Token);
FlSetFilename (Filename);
}
/* Third argument is not supported at this time */
ResetAndExit:
AslResetCurrentLineBuffer ();
}
/*******************************************************************************
*
* 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
AslPopInputFileStack (
void)
{
ASL_FILE_NODE *Fnode;
Fnode = Gbl_IncludeFileStack;
DbgPrint (ASL_PARSE_OUTPUT, "\nPop InputFile Stack, Fnode %p\n\n", Fnode);
if (!Fnode)
{
return (-1);
}
/* Close the current include file */
fclose (yyin);
/* Update the top-of-stack */
Gbl_IncludeFileStack = Fnode->Next;
/* Reset global line counter and filename */
Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
/* Point the parser to the popped file */
yy_delete_buffer (YY_CURRENT_BUFFER);
yy_switch_to_buffer (Fnode->State);
/* All done with this node */
ACPI_FREE (Fnode);
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
AslPushInputFileStack (
FILE *InputFile,
char *Filename)
{
ASL_FILE_NODE *Fnode;
YY_BUFFER_STATE State;
/* Save the current state in an Fnode */
Fnode = UtLocalCalloc (sizeof (ASL_FILE_NODE));
Fnode->File = yyin;
Fnode->Next = Gbl_IncludeFileStack;
Fnode->State = YY_CURRENT_BUFFER;
Fnode->CurrentLineNumber = Gbl_CurrentLineNumber;
Fnode->Filename = Gbl_Files[ASL_FILE_INPUT].Filename;
/* Push it on the stack */
Gbl_IncludeFileStack = Fnode;
/* Point the parser to this file */
State = yy_create_buffer (InputFile, YY_BUF_SIZE);
yy_switch_to_buffer (State);
DbgPrint (ASL_PARSE_OUTPUT, "\nPush InputFile Stack, returning %p\n\n", InputFile);
/* Reset the global line count and filename */
Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
Gbl_CurrentLineNumber = 1;
yyin = InputFile;
}
/*******************************************************************************
*
* FUNCTION: AslResetCurrentLineBuffer
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Reset the Line Buffer to zero, increment global line numbers.
*
******************************************************************************/
void
AslResetCurrentLineBuffer (
void)
{
if (Gbl_Files[ASL_FILE_SOURCE_OUTPUT].Handle)
{
FlWriteFile (ASL_FILE_SOURCE_OUTPUT, Gbl_CurrentLineBuffer,
Gbl_LineBufPtr - Gbl_CurrentLineBuffer);
}
Gbl_CurrentLineOffset += Gbl_CurrentColumn;
Gbl_CurrentColumn = 0;
Gbl_CurrentLineNumber++;
Gbl_LogicalLineNumber++;
Gbl_LineBufPtr = Gbl_CurrentLineBuffer;
}
/*******************************************************************************
*
* 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
AslInsertLineBuffer (
int SourceChar)
{
UINT32 i;
UINT32 Count = 1;
if (SourceChar == EOF)
{
return;
}
Gbl_InputByteCount++;
/* Handle tabs. Convert to spaces */
if (SourceChar == '\t')
{
SourceChar = ' ';
Count = ASL_SPACES_PER_TAB -
(Gbl_CurrentColumn & (ASL_SPACES_PER_TAB-1));
}
for (i = 0; i < Count; i++)
{
Gbl_CurrentColumn++;
/* Insert the character into the line buffer */
*Gbl_LineBufPtr = (UINT8) SourceChar;
Gbl_LineBufPtr++;
if (Gbl_LineBufPtr > (Gbl_CurrentLineBuffer + (ASL_LINE_BUFFER_SIZE - 1)))
{
#if 0
/*
* Warning if we have split a long source line.
* <Probably overkill>
*/
sprintf (MsgBuffer, "Max %u", ASL_LINE_BUFFER_SIZE);
AslCommonError (ASL_WARNING, ASL_MSG_LONG_LINE,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, MsgBuffer);
#endif
AslResetCurrentLineBuffer ();
}
else if (SourceChar == '\n')
{
/* End of line */
AslResetCurrentLineBuffer ();
}
}
}
/*******************************************************************************
*
* FUNCTION: count
*
* PARAMETERS: yytext - Contains the matched keyword.
* Type - Keyword/Character type:
* 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:
TotalKeywords++;
TotalNamedObjects++;
break;
case 3:
TotalKeywords++;
TotalExecutableOpcodes++;
break;
}
for (i = 0; (yytext[i] != 0) && (yytext[i] != EOF); i++)
{
AslInsertLineBuffer (yytext[i]);
*Gbl_LineBufPtr = 0;
}
}
/*******************************************************************************
*
* FUNCTION: AslDoComment
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Process a standard comment.
*
******************************************************************************/
static char
AslDoComment (
void)
{
char c;
char c1 = 0;
AslInsertLineBuffer ('/');
AslInsertLineBuffer ('*');
loop:
/* Eat chars until end-of-comment */
while ((c = (char) input()) != '*' && c != EOF)
{
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
*/
if ((c1 == '/') && (c == '*'))
{
AslCommonError (ASL_WARNING, ASL_MSG_NESTED_COMMENT,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_InputByteCount, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
}
/* Comment is closed only if the NEXT character is a slash */
AslInsertLineBuffer (c);
if ((c1 = (char) input()) != '/' && c1 != EOF)
{
unput(c1);
goto loop;
}
if (c1 == EOF)
{
goto EarlyEOF;
}
AslInsertLineBuffer (c1);
return (TRUE);
EarlyEOF:
/*
* Premature End-Of-File
*/
AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
return (FALSE);
}
/*******************************************************************************
*
* FUNCTION: AslDoCommentType2
*
* PARAMETERS: none
*
* RETURN: none
*
* DESCRIPTION: Process a new "//" comment.
*
******************************************************************************/
static char
AslDoCommentType2 (
void)
{
char c;
AslInsertLineBuffer ('/');
AslInsertLineBuffer ('/');
while ((c = (char) input()) != '\n' && c != EOF)
{
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
AslDoStringLiteral (
void)
{
char *StringBuffer = MsgBuffer;
char *EndBuffer = MsgBuffer + ASL_MSG_BUFFER_SIZE;
char *CleanString;
char StringChar;
UINT32 State = ASL_NORMAL_CHAR;
UINT32 i = 0;
UINT8 Digit;
char ConvertBuffer[4];
/*
* Eat chars until end-of-literal.
* NOTE: Put back the original surrounding quotes into the
* source line buffer.
*/
AslInsertLineBuffer ('\"');
while ((StringChar = (char) input()) != EOF)
{
AslInsertLineBuffer (StringChar);
DoCharacter:
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).
*/
State = ASL_ESCAPE_SEQUENCE;
continue;
case '\"':
/* String terminator */
goto CompletedString;
}
break;
case ASL_ESCAPE_SEQUENCE:
State = ASL_NORMAL_CHAR;
switch (StringChar)
{
case 'a':
StringChar = 0x07; /* BELL */
break;
case 'b':
StringChar = 0x08; /* BACKSPACE */
break;
case 'f':
StringChar = 0x0C; /* FORMFEED */
break;
case 'n':
StringChar = 0x0A; /* LINEFEED */
break;
case 'r':
StringChar = 0x0D; /* CARRIAGE RETURN*/
break;
case 't':
StringChar = 0x09; /* HORIZONTAL TAB */
break;
case 'v':
StringChar = 0x0B; /* VERTICAL TAB */
break;
case 'x':
State = ASL_HEX_CONSTANT;
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))
{
State = ASL_OCTAL_CONSTANT;
ConvertBuffer[0] = StringChar;
i = 1;
continue;
}
/* Unknown escape sequence issue warning, but use the character */
AslCommonError (ASL_WARNING, ASL_MSG_INVALID_ESCAPE,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
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;
Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 8);
/* Check for NULL or non-ascii character (ignore if so) */
if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
{
AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
}
else
{
*StringBuffer = (char) Digit;
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
State = ASL_NORMAL_CHAR;
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 (!ACPI_IS_XDIGIT (StringChar) ||
(i > 1))
{
/*
* Reached end of the constant. Convert the assembled ASCII
* string and resume processing of the next character
*/
ConvertBuffer[i] = 0;
Digit = (UINT8) ACPI_STRTOUL (ConvertBuffer, NULL, 16);
/* Check for NULL or non-ascii character (ignore if so) */
if ((Digit == 0) || (Digit > ACPI_ASCII_MAX))
{
AslCommonError (ASL_WARNING, ASL_MSG_INVALID_STRING,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
}
else
{
*StringBuffer = (char) Digit;
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
State = ASL_NORMAL_CHAR;
goto DoCharacter;
break;
}
/* Append another digit of the constant */
ConvertBuffer[i] = StringChar;
i++;
continue;
}
/* Save the finished character */
*StringBuffer = StringChar;
StringBuffer++;
if (StringBuffer >= EndBuffer)
{
goto BufferOverflow;
}
}
/*
* Premature End-Of-File
*/
AslCommonError (ASL_ERROR, ASL_MSG_EARLY_EOF,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
return (FALSE);
CompletedString:
/*
* Null terminate the input string and copy string to a new buffer
*/
*StringBuffer = 0;
CleanString = UtGetStringBuffer (strlen (MsgBuffer) + 1);
if (!CleanString)
{
AslCommonError (ASL_ERROR, ASL_MSG_MEMORY_ALLOCATION,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, NULL);
return (FALSE);
}
ACPI_STRCPY (CleanString, MsgBuffer);
AslCompilerlval.s = CleanString;
return (TRUE);
BufferOverflow:
/* Literal was too long */
AslCommonError (ASL_ERROR, ASL_MSG_STRING_LENGTH,
Gbl_CurrentLineNumber, Gbl_LogicalLineNumber,
Gbl_CurrentLineOffset, Gbl_CurrentColumn,
Gbl_Files[ASL_FILE_INPUT].Filename, "Max length 4096");
return (FALSE);
}

42
sys/contrib/dev/acpica/compiler/dtio.c
View File

@ -89,6 +89,7 @@ DtDumpBuffer (
#define DT_SLASH_SLASH_COMMENT 4 #define DT_SLASH_SLASH_COMMENT 4
#define DT_END_COMMENT 5 #define DT_END_COMMENT 5
#define DT_MERGE_LINES 6 #define DT_MERGE_LINES 6
#define DT_ESCAPE_SEQUENCE 7
static UINT32 Gbl_NextLineOffset; static UINT32 Gbl_NextLineOffset;
@ -412,6 +413,7 @@ DtGetNextLine (
BOOLEAN LineNotAllBlanks = FALSE; BOOLEAN LineNotAllBlanks = FALSE;
UINT32 State = DT_NORMAL_TEXT; UINT32 State = DT_NORMAL_TEXT;
UINT32 CurrentLineOffset; UINT32 CurrentLineOffset;
UINT32 BeyondBufferCount;
UINT32 i; UINT32 i;
char c; char c;
@ -503,12 +505,36 @@ DtGetNextLine (
Gbl_CurrentLineBuffer[i] = c; Gbl_CurrentLineBuffer[i] = c;
i++; i++;
if (c == '"') switch (c)
{ {
case '"':
State = DT_NORMAL_TEXT; State = DT_NORMAL_TEXT;
break;
case '\\':
State = DT_ESCAPE_SEQUENCE;
break;
case '\n':
AcpiOsPrintf ("ERROR at line %u: Unterminated quoted string\n",
Gbl_CurrentLineNumber++);
State = DT_NORMAL_TEXT;
break;
default: /* Get next character */
break;
} }
break; break;
case DT_ESCAPE_SEQUENCE:
/* Just copy the escaped character. TBD: sufficient for table compiler? */
Gbl_CurrentLineBuffer[i] = c;
i++;
State = DT_START_QUOTED_STRING;
break;
case DT_START_COMMENT: case DT_START_COMMENT:
/* Open comment if this character is an asterisk or slash */ /* Open comment if this character is an asterisk or slash */
@ -629,7 +655,19 @@ DtGetNextLine (
} }
} }
printf ("ERROR - Input line is too long (max %u)\n", ASL_LINE_BUFFER_SIZE); /* Line is too long for internal buffer. Determine actual length */
BeyondBufferCount = 1;
c = (char) getc (Handle);
while (c != '\n')
{
c = (char) getc (Handle);
BeyondBufferCount++;
}
printf ("ERROR - At %u: Input line (%u bytes) is too long (max %u)\n",
Gbl_CurrentLineNumber++, ASL_LINE_BUFFER_SIZE + BeyondBufferCount,
ASL_LINE_BUFFER_SIZE);
return (ASL_EOF); return (ASL_EOF);
} }

17
sys/contrib/dev/acpica/compiler/preprocess.h
View File

@ -124,13 +124,6 @@ typedef struct pr_file_node
} PR_FILE_NODE; } PR_FILE_NODE;
typedef struct pr_line_mapping
{
UINT32 *Map;
struct pr_line_mapping *Next;
} PR_LINE_MAPPING;
/* /*
* Globals * Globals
@ -140,7 +133,6 @@ PR_EXTERN char Gbl_MainTokenBuffer[ASL_LINE_BUFFER_SIZE];
PR_EXTERN char Gbl_MacroTokenBuffer[ASL_LINE_BUFFER_SIZE]; PR_EXTERN char Gbl_MacroTokenBuffer[ASL_LINE_BUFFER_SIZE];
PR_EXTERN char Gbl_ExpressionTokenBuffer[ASL_LINE_BUFFER_SIZE]; PR_EXTERN char Gbl_ExpressionTokenBuffer[ASL_LINE_BUFFER_SIZE];
PR_EXTERN PR_LINE_MAPPING *Gbl_MapBlockHead;
PR_EXTERN PR_FILE_NODE *Gbl_InputFileList; PR_EXTERN PR_FILE_NODE *Gbl_InputFileList;
PR_EXTERN PR_DEFINE_INFO PR_INIT_GLOBAL (*Gbl_DefineList, NULL); PR_EXTERN PR_DEFINE_INFO PR_INIT_GLOBAL (*Gbl_DefineList, NULL);
PR_EXTERN UINT32 Gbl_PreprocessorLineNumber; PR_EXTERN UINT32 Gbl_PreprocessorLineNumber;
@ -167,10 +159,6 @@ BOOLEAN
PrDoPreprocess ( PrDoPreprocess (
void); void);
UINT32
PrGetLineNumber (
UINT32 PreprocessorLineNumber);
UINT64 UINT64
PrIsDefined ( PrIsDefined (
char *Identifier); char *Identifier);
@ -251,11 +239,6 @@ PrGetNextToken (
char *MatchString, char *MatchString,
char **Next); char **Next);
void
PrSetLineNumber (
UINT32 OriginalLineNumber,
UINT32 NewLineNumber);
void void
PrError ( PrError (
UINT8 Level, UINT8 Level,

71
sys/contrib/dev/acpica/compiler/prscan.c
View File

@ -161,9 +161,6 @@ PrInitializeGlobals (
Gbl_CurrentLineNumber = 0; Gbl_CurrentLineNumber = 0;
Gbl_PreprocessorLineNumber = 1; Gbl_PreprocessorLineNumber = 1;
Gbl_PreprocessorError = FALSE; Gbl_PreprocessorError = FALSE;
Gbl_MapBlockHead = UtLocalCalloc (sizeof (PR_LINE_MAPPING));
Gbl_MapBlockHead->Map = UtLocalCalloc (PR_LINES_PER_BLOCK * sizeof (UINT32));
} }
@ -186,7 +183,6 @@ PrTerminatePreprocessor (
void) void)
{ {
PR_DEFINE_INFO *DefineInfo; PR_DEFINE_INFO *DefineInfo;
PR_LINE_MAPPING *MapInfo;
/* /*
@ -202,17 +198,6 @@ PrTerminatePreprocessor (
ACPI_FREE (DefineInfo->Identifier); ACPI_FREE (DefineInfo->Identifier);
ACPI_FREE (DefineInfo); ACPI_FREE (DefineInfo);
} }
/* Clear the line number mappings */
while (Gbl_MapBlockHead)
{
MapInfo = Gbl_MapBlockHead;
Gbl_MapBlockHead = MapInfo->Next;
ACPI_FREE (MapInfo->Map);
ACPI_FREE (MapInfo);
}
} }
@ -393,8 +378,6 @@ PrPreprocessInputFile (
Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next); Token = PrGetNextToken (NULL, PR_TOKEN_SEPARATORS, &Next);
} }
/* Write the possibly modified line to the .i file*/
#if 0 #if 0
/* Line prefix */ /* Line prefix */
FlPrintFile (ASL_FILE_PREPROCESSOR, "/* %14s %.5u i:%.5u */ ", FlPrintFile (ASL_FILE_PREPROCESSOR, "/* %14s %.5u i:%.5u */ ",
@ -402,11 +385,27 @@ PrPreprocessInputFile (
Gbl_CurrentLineNumber, Gbl_PreprocessorLineNumber); Gbl_CurrentLineNumber, Gbl_PreprocessorLineNumber);
#endif #endif
/*
* Emit a #line directive if necessary, to keep the line numbers in
* the (.i) file synchronized with the original source code file, so
* that the correct line number appears in any error messages
* generated by the actual compiler.
*/
if (Gbl_CurrentLineNumber > (Gbl_PreviousLineNumber + 1))
{
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u\n",
Gbl_CurrentLineNumber);
}
Gbl_PreviousLineNumber = Gbl_CurrentLineNumber;
Gbl_PreprocessorLineNumber++;
/*
* Now we can write the possibly modified source line to the
* preprocessor (.i) file
*/
FlWriteFile (ASL_FILE_PREPROCESSOR, Gbl_CurrentLineBuffer, FlWriteFile (ASL_FILE_PREPROCESSOR, Gbl_CurrentLineBuffer,
strlen (Gbl_CurrentLineBuffer)); strlen (Gbl_CurrentLineBuffer));
PrSetLineNumber (Gbl_CurrentLineNumber, Gbl_PreprocessorLineNumber);
Gbl_PreprocessorLineNumber++;
} }
} }
@ -546,8 +545,9 @@ PrDoDirective (
if (*(&Gbl_CurrentLineBuffer[TokenOffset]) == '(') if (*(&Gbl_CurrentLineBuffer[TokenOffset]) == '(')
{ {
#ifndef MACROS_SUPPORTED #ifndef MACROS_SUPPORTED
AcpiOsPrintf ("#define macros not supported\n"); AcpiOsPrintf ("%s ERROR - line %u: #define macros are not supported yet\n",
goto SyntaxError; Gbl_CurrentLineBuffer, Gbl_CurrentLineNumber);
exit(1);
#else #else
PrAddMacro (Token, Next); PrAddMacro (Token, Next);
#endif #endif
@ -660,6 +660,31 @@ PrDoDirective (
PrOpenIncludeFile (Token); PrOpenIncludeFile (Token);
break; break;
case PR_DIRECTIVE_LINE:
TokenOffset = Token - Gbl_MainTokenBuffer;
Status = PrResolveIntegerExpression (
&Gbl_CurrentLineBuffer[TokenOffset-1], &Value);
if (ACPI_FAILURE (Status))
{
return;
}
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID
"User #line invocation %s\n", Gbl_CurrentLineNumber,
Token);
/* Update local line numbers */
Gbl_CurrentLineNumber = (UINT32) Value;
Gbl_PreviousLineNumber = 0;
/* Emit #line into the preprocessor file */
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
Gbl_CurrentLineNumber, Gbl_Files[ASL_FILE_INPUT].Filename);
break;
case PR_DIRECTIVE_PRAGMA: case PR_DIRECTIVE_PRAGMA:
/* Only "#pragma message" supported at this time */ /* Only "#pragma message" supported at this time */
@ -692,8 +717,6 @@ PrDoDirective (
THIS_TOKEN_OFFSET (Token)); THIS_TOKEN_OFFSET (Token));
break; break;
case PR_DIRECTIVE_LINE:
/* TBD: set line number -- or, do this in main compiler */
default: default:
/* Should never get here */ /* Should never get here */
DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID DbgPrint (ASL_DEBUG_OUTPUT, PR_PREFIX_ID

110
sys/contrib/dev/acpica/compiler/prutils.c
View File

@ -49,100 +49,6 @@
ACPI_MODULE_NAME ("prutils") ACPI_MODULE_NAME ("prutils")
/*******************************************************************************
*
* FUNCTION: PrSetLineNumber
*
* PARAMETERS: OriginalLineNumber - Line number in original source file,
* or include file
* PreprocessorLineNumber - Line number in the preprocessed file
*
* RETURN: None
*
* DESCRIPTION: Insert this mapping into the mapping data structure, for use
* in possible error/warning messages.
*
* Line number mapping functions.
* For error messages, we need to keep track of the line number in the
* original file, versus the preprocessed (.i) file.
*
******************************************************************************/
void
PrSetLineNumber (
UINT32 OriginalLineNumber,
UINT32 PreprocessorLineNumber)
{
UINT32 Entry;
PR_LINE_MAPPING *Block;
UINT32 Index;
UINT32 i;
Entry = PreprocessorLineNumber / PR_LINES_PER_BLOCK;
Index = PreprocessorLineNumber % PR_LINES_PER_BLOCK;
Block = Gbl_MapBlockHead;
for (i = 0; i < Entry; i++)
{
/* Allocate new mapping blocks as necessary */
if (!Block->Next)
{
Block->Next = UtLocalCalloc (sizeof (PR_LINE_MAPPING));
Block->Next->Map = UtLocalCalloc (PR_LINES_PER_BLOCK * sizeof (UINT32));
}
Block = Block->Next;
}
Block->Map[Index] = OriginalLineNumber;
}
/*******************************************************************************
*
* FUNCTION: PrGetLineNumber
*
* PARAMETERS: PreprocessorLineNumber - Line number in the preprocessed file
* (or, the "logical line number)
*
* RETURN: The line number in the original source file or include file.
*
* DESCRIPTION: Return the mapped value of a line number in the preprocessed
* source file to the actual line number in the original source
* file.
*
******************************************************************************/
UINT32
PrGetLineNumber (
UINT32 PreprocessorLineNumber)
{
UINT32 Entry;
PR_LINE_MAPPING *Block;
UINT32 Index;
UINT32 i;
Entry = PreprocessorLineNumber / PR_LINES_PER_BLOCK;
Index = PreprocessorLineNumber % PR_LINES_PER_BLOCK;
Block = Gbl_MapBlockHead;
for (i = 0; i < Entry; i++)
{
Block = Block->Next;
if (!Block)
{
/* Bad error, should not happen */
return (0);
}
}
return (Block->Map[Index]);
}
/****************************************************************************** /******************************************************************************
* *
* FUNCTION: PrGetNextToken * FUNCTION: PrGetNextToken
@ -486,14 +392,20 @@ PrPushInputFileStack (
Gbl_InputFileList = Fnode; Gbl_InputFileList = Fnode;
DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID DbgPrint (ASL_PARSE_OUTPUT, PR_PREFIX_ID
"Push InputFile Stack, returning %p\n\n", "Push InputFile Stack: handle %p\n\n",
Gbl_CurrentLineNumber, InputFile); Gbl_CurrentLineNumber, InputFile);
/* Reset the global line count and filename */ /* Reset the global line count and filename */
Gbl_Files[ASL_FILE_INPUT].Filename = Filename; Gbl_Files[ASL_FILE_INPUT].Filename = Filename;
Gbl_Files[ASL_FILE_INPUT].Handle = InputFile; Gbl_Files[ASL_FILE_INPUT].Handle = InputFile;
Gbl_CurrentLineNumber = 1; Gbl_PreviousLineNumber = 0;
Gbl_CurrentLineNumber = 0;
/* Emit a new #line directive for the include file */
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
1, Filename);
} }
@ -542,6 +454,12 @@ PrPopInputFileStack (
Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename; Gbl_Files[ASL_FILE_INPUT].Filename = Fnode->Filename;
Gbl_Files[ASL_FILE_INPUT].Handle = Fnode->File; Gbl_Files[ASL_FILE_INPUT].Handle = Fnode->File;
Gbl_CurrentLineNumber = Fnode->CurrentLineNumber; Gbl_CurrentLineNumber = Fnode->CurrentLineNumber;
Gbl_PreviousLineNumber = 0;
/* Emit a new #line directive after the include file */
FlPrintFile (ASL_FILE_PREPROCESSOR, "#line %u \"%s\"\n",
Gbl_CurrentLineNumber + 1, Fnode->Filename);
/* All done with this node */ /* All done with this node */

19
sys/contrib/dev/acpica/components/debugger/dbcmds.c
View File

@ -373,25 +373,20 @@ AcpiDbSendNotify (
return; return;
} }
/* Decode Named object type */ /* Dispatch the notify if legal */
switch (Node->Type) if (AcpiEvIsNotifyObject (Node))
{ {
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_THERMAL:
/* Send the notify */
Status = AcpiEvQueueNotifyRequest (Node, Value); Status = AcpiEvQueueNotifyRequest (Node, Value);
if (ACPI_FAILURE (Status)) if (ACPI_FAILURE (Status))
{ {
AcpiOsPrintf ("Could not queue notify\n"); AcpiOsPrintf ("Could not queue notify\n");
} }
break; }
else
default: {
AcpiOsPrintf ("Named object is not a device or a thermal object\n"); AcpiOsPrintf ("Named object [%4.4s] Type %s, must be Device/Thermal/Processor type\n",
break; AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type));
} }
} }

4
sys/contrib/dev/acpica/components/debugger/dbdisply.c
View File

@ -107,8 +107,8 @@ typedef struct acpi_handler_info
static ACPI_HANDLER_INFO AcpiGbl_HandlerList[] = static ACPI_HANDLER_INFO AcpiGbl_HandlerList[] =
{ {
{&AcpiGbl_SystemNotify.Handler, "System Notifications"}, {&AcpiGbl_GlobalNotify[0].Handler, "System Notifications"},
{&AcpiGbl_DeviceNotify.Handler, "Device Notifications"}, {&AcpiGbl_GlobalNotify[1].Handler, "Device Notifications"},
{&AcpiGbl_TableHandler, "ACPI Table Events"}, {&AcpiGbl_TableHandler, "ACPI Table Events"},
{&AcpiGbl_ExceptionHandler, "Control Method Exceptions"}, {&AcpiGbl_ExceptionHandler, "Control Method Exceptions"},
{&AcpiGbl_InterfaceHandler, "OSI Invocations"} {&AcpiGbl_InterfaceHandler, "OSI Invocations"}

28
sys/contrib/dev/acpica/components/debugger/dbstats.c
View File

@ -227,8 +227,8 @@ AcpiDbEnumerateObject (
case ACPI_TYPE_DEVICE: case ACPI_TYPE_DEVICE:
AcpiDbEnumerateObject (ObjDesc->Device.SystemNotify); AcpiDbEnumerateObject (ObjDesc->Device.NotifyList[0]);
AcpiDbEnumerateObject (ObjDesc->Device.DeviceNotify); AcpiDbEnumerateObject (ObjDesc->Device.NotifyList[1]);
AcpiDbEnumerateObject (ObjDesc->Device.Handler); AcpiDbEnumerateObject (ObjDesc->Device.Handler);
break; break;
@ -248,21 +248,21 @@ AcpiDbEnumerateObject (
case ACPI_TYPE_POWER: case ACPI_TYPE_POWER:
AcpiDbEnumerateObject (ObjDesc->PowerResource.SystemNotify); AcpiDbEnumerateObject (ObjDesc->PowerResource.NotifyList[0]);
AcpiDbEnumerateObject (ObjDesc->PowerResource.DeviceNotify); AcpiDbEnumerateObject (ObjDesc->PowerResource.NotifyList[1]);
break; break;
case ACPI_TYPE_PROCESSOR: case ACPI_TYPE_PROCESSOR:
AcpiDbEnumerateObject (ObjDesc->Processor.SystemNotify); AcpiDbEnumerateObject (ObjDesc->Processor.NotifyList[0]);
AcpiDbEnumerateObject (ObjDesc->Processor.DeviceNotify); AcpiDbEnumerateObject (ObjDesc->Processor.NotifyList[1]);
AcpiDbEnumerateObject (ObjDesc->Processor.Handler); AcpiDbEnumerateObject (ObjDesc->Processor.Handler);
break; break;
case ACPI_TYPE_THERMAL: case ACPI_TYPE_THERMAL:
AcpiDbEnumerateObject (ObjDesc->ThermalZone.SystemNotify); AcpiDbEnumerateObject (ObjDesc->ThermalZone.NotifyList[0]);
AcpiDbEnumerateObject (ObjDesc->ThermalZone.DeviceNotify); AcpiDbEnumerateObject (ObjDesc->ThermalZone.NotifyList[1]);
AcpiDbEnumerateObject (ObjDesc->ThermalZone.Handler); AcpiDbEnumerateObject (ObjDesc->ThermalZone.Handler);
break; break;
@ -522,6 +522,18 @@ AcpiDbDisplayStatistics (
AcpiOsPrintf ("NamespaceNode %3d\n", sizeof (ACPI_NAMESPACE_NODE)); AcpiOsPrintf ("NamespaceNode %3d\n", sizeof (ACPI_NAMESPACE_NODE));
AcpiOsPrintf ("AcpiObject %3d\n", sizeof (ACPI_OBJECT)); AcpiOsPrintf ("AcpiObject %3d\n", sizeof (ACPI_OBJECT));
AcpiOsPrintf ("\n");
AcpiOsPrintf ("Generic State %3d\n", sizeof (ACPI_GENERIC_STATE));
AcpiOsPrintf ("Common State %3d\n", sizeof (ACPI_COMMON_STATE));
AcpiOsPrintf ("Control State %3d\n", sizeof (ACPI_CONTROL_STATE));
AcpiOsPrintf ("Update State %3d\n", sizeof (ACPI_UPDATE_STATE));
AcpiOsPrintf ("Scope State %3d\n", sizeof (ACPI_SCOPE_STATE));
AcpiOsPrintf ("Parse Scope %3d\n", sizeof (ACPI_PSCOPE_STATE));
AcpiOsPrintf ("Package State %3d\n", sizeof (ACPI_PKG_STATE));
AcpiOsPrintf ("Thread State %3d\n", sizeof (ACPI_THREAD_STATE));
AcpiOsPrintf ("Result Values %3d\n", sizeof (ACPI_RESULT_VALUES));
AcpiOsPrintf ("Notify Info %3d\n", sizeof (ACPI_NOTIFY_INFO));
break; break;

5
sys/contrib/dev/acpica/components/debugger/dbutils.c
View File

@ -190,10 +190,7 @@ AcpiDbDumpExternalObject (
case ACPI_TYPE_STRING: case ACPI_TYPE_STRING:
AcpiOsPrintf ("[String] Length %.2X = ", ObjDesc->String.Length); AcpiOsPrintf ("[String] Length %.2X = ", ObjDesc->String.Length);
for (i = 0; i < ObjDesc->String.Length; i++) AcpiUtPrintString (ObjDesc->String.Pointer, ACPI_UINT8_MAX);
{
AcpiOsPrintf ("%c", ObjDesc->String.Pointer[i]);
}
AcpiOsPrintf ("\n"); AcpiOsPrintf ("\n");
break; break;

201
sys/contrib/dev/acpica/components/events/evmisc.c
View File

@ -111,107 +111,82 @@ AcpiEvQueueNotifyRequest (
UINT32 NotifyValue) UINT32 NotifyValue)
{ {
ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *HandlerObj = NULL; ACPI_OPERAND_OBJECT *HandlerListHead = NULL;
ACPI_GENERIC_STATE *NotifyInfo; ACPI_GENERIC_STATE *Info;
UINT8 HandlerListId = 0;
ACPI_STATUS Status = AE_OK; ACPI_STATUS Status = AE_OK;
ACPI_FUNCTION_NAME (EvQueueNotifyRequest); ACPI_FUNCTION_NAME (EvQueueNotifyRequest);
/* Are Notifies allowed on this object? */
if (!AcpiEvIsNotifyObject (Node))
{
return (AE_TYPE);
}
/* Get the correct notify list type (System or Device) */
if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
{
HandlerListId = ACPI_SYSTEM_HANDLER_LIST;
}
else
{
HandlerListId = ACPI_DEVICE_HANDLER_LIST;
}
/* Get the notify object attached to the namespace Node */
ObjDesc = AcpiNsGetAttachedObject (Node);
if (ObjDesc)
{
/* We have an attached object, Get the correct handler list */
HandlerListHead = ObjDesc->CommonNotify.NotifyList[HandlerListId];
}
/* /*
* For value 0x03 (Ejection Request), may need to run a device method. * If there is no notify handler (Global or Local)
* For value 0x02 (Device Wake), if _PRW exists, may need to run * for this object, just ignore the notify
* the _PS0 method.
* For value 0x80 (Status Change) on the power button or sleep button,
* initiate soft-off or sleep operation.
*
* For all cases, simply dispatch the notify to the handler.
*/ */
if (!AcpiGbl_GlobalNotify[HandlerListId].Handler && !HandlerListHead)
{
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"No notify handler for Notify, ignoring (%4.4s, %X) node %p\n",
AcpiUtGetNodeName (Node), NotifyValue, Node));
return (AE_OK);
}
/* Setup notify info and schedule the notify dispatcher */
Info = AcpiUtCreateGenericState ();
if (!Info)
{
return (AE_NO_MEMORY);
}
Info->Common.DescriptorType = ACPI_DESC_TYPE_STATE_NOTIFY;
Info->Notify.Node = Node;
Info->Notify.Value = (UINT16) NotifyValue;
Info->Notify.HandlerListId = HandlerListId;
Info->Notify.HandlerListHead = HandlerListHead;
Info->Notify.Global = &AcpiGbl_GlobalNotify[HandlerListId];
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Dispatching Notify on [%4.4s] (%s) Value 0x%2.2X (%s) Node %p\n", "Dispatching Notify on [%4.4s] (%s) Value 0x%2.2X (%s) Node %p\n",
AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type), AcpiUtGetNodeName (Node), AcpiUtGetTypeName (Node->Type),
NotifyValue, AcpiUtGetNotifyName (NotifyValue), Node)); NotifyValue, AcpiUtGetNotifyName (NotifyValue), Node));
/* Get the notify object attached to the NS Node */ Status = AcpiOsExecute (OSL_NOTIFY_HANDLER, AcpiEvNotifyDispatch,
Info);
ObjDesc = AcpiNsGetAttachedObject (Node); if (ACPI_FAILURE (Status))
if (ObjDesc)
{ {
/* We have the notify object, Get the correct handler */ AcpiUtDeleteGenericState (Info);
switch (Node->Type)
{
/* Notify is allowed only on these types */
case ACPI_TYPE_DEVICE:
case ACPI_TYPE_THERMAL:
case ACPI_TYPE_PROCESSOR:
if (NotifyValue <= ACPI_MAX_SYS_NOTIFY)
{
HandlerObj = ObjDesc->CommonNotify.SystemNotify;
}
else
{
HandlerObj = ObjDesc->CommonNotify.DeviceNotify;
}
break;
default:
/* All other types are not supported */
return (AE_TYPE);
}
}
/*
* If there is a handler to run, schedule the dispatcher.
* Check for:
* 1) Global system notify handler
* 2) Global device notify handler
* 3) Per-device notify handler
*/
if ((AcpiGbl_SystemNotify.Handler &&
(NotifyValue <= ACPI_MAX_SYS_NOTIFY)) ||
(AcpiGbl_DeviceNotify.Handler &&
(NotifyValue > ACPI_MAX_SYS_NOTIFY)) ||
HandlerObj)
{
NotifyInfo = AcpiUtCreateGenericState ();
if (!NotifyInfo)
{
return (AE_NO_MEMORY);
}
if (!HandlerObj)
{
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Executing system notify handler for Notify (%4.4s, %X) "
"node %p\n",
AcpiUtGetNodeName (Node), NotifyValue, Node));
}
NotifyInfo->Common.DescriptorType = ACPI_DESC_TYPE_STATE_NOTIFY;
NotifyInfo->Notify.Node = Node;
NotifyInfo->Notify.Value = (UINT16) NotifyValue;
NotifyInfo->Notify.HandlerObj = HandlerObj;
Status = AcpiOsExecute (
OSL_NOTIFY_HANDLER, AcpiEvNotifyDispatch, NotifyInfo);
if (ACPI_FAILURE (Status))
{
AcpiUtDeleteGenericState (NotifyInfo);
}
}
else
{
/* There is no notify handler (per-device or system) for this device */
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"No notify handler for Notify (%4.4s, %X) node %p\n",
AcpiUtGetNodeName (Node), NotifyValue, Node));
} }
return (Status); return (Status);
@ -235,61 +210,37 @@ static void ACPI_SYSTEM_XFACE
AcpiEvNotifyDispatch ( AcpiEvNotifyDispatch (
void *Context) void *Context)
{ {
ACPI_GENERIC_STATE *NotifyInfo = (ACPI_GENERIC_STATE *) Context; ACPI_GENERIC_STATE *Info = (ACPI_GENERIC_STATE *) Context;
ACPI_NOTIFY_HANDLER GlobalHandler = NULL;
void *GlobalContext = NULL;
ACPI_OPERAND_OBJECT *HandlerObj; ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_FUNCTION_ENTRY (); ACPI_FUNCTION_ENTRY ();
/* /* Invoke a global notify handler if installed */
* We will invoke a global notify handler if installed. This is done
* _before_ we invoke the per-device handler attached to the device.
*/
if (NotifyInfo->Notify.Value <= ACPI_MAX_SYS_NOTIFY)
{
/* Global system notification handler */
if (AcpiGbl_SystemNotify.Handler) if (Info->Notify.Global->Handler)
{
GlobalHandler = AcpiGbl_SystemNotify.Handler;
GlobalContext = AcpiGbl_SystemNotify.Context;
}
}
else
{ {
/* Global driver notification handler */ Info->Notify.Global->Handler (Info->Notify.Node,
Info->Notify.Value,
if (AcpiGbl_DeviceNotify.Handler) Info->Notify.Global->Context);
{
GlobalHandler = AcpiGbl_DeviceNotify.Handler;
GlobalContext = AcpiGbl_DeviceNotify.Context;
}
} }
/* Invoke the system handler first, if present */ /* Now invoke the local notify handler(s) if any are installed */
if (GlobalHandler) HandlerObj = Info->Notify.HandlerListHead;
while (HandlerObj)
{ {
GlobalHandler (NotifyInfo->Notify.Node, NotifyInfo->Notify.Value, HandlerObj->Notify.Handler (Info->Notify.Node,
GlobalContext); Info->Notify.Value,
}
/* Now invoke the per-device handler, if present */
HandlerObj = NotifyInfo->Notify.HandlerObj;
if (HandlerObj)
{
HandlerObj->Notify.Handler (NotifyInfo->Notify.Node,
NotifyInfo->Notify.Value,
HandlerObj->Notify.Context); HandlerObj->Notify.Context);
HandlerObj = HandlerObj->Notify.Next[Info->Notify.HandlerListId];
} }
/* All done with the info object */ /* All done with the info object */
AcpiUtDeleteGenericState (NotifyInfo); AcpiUtDeleteGenericState (Info);
} }

364
sys/contrib/dev/acpica/components/events/evxface.c
View File

@ -60,15 +60,21 @@
* *
* PARAMETERS: Device - The device for which notifies will be handled * PARAMETERS: Device - The device for which notifies will be handled
* HandlerType - The type of handler: * HandlerType - The type of handler:
* ACPI_SYSTEM_NOTIFY: SystemHandler (00-7f) * ACPI_SYSTEM_NOTIFY: System Handler (00-7F)
* ACPI_DEVICE_NOTIFY: DriverHandler (80-ff) * ACPI_DEVICE_NOTIFY: Device Handler (80-FF)
* ACPI_ALL_NOTIFY: both system and device * ACPI_ALL_NOTIFY: Both System and Device
* Handler - Address of the handler * Handler - Address of the handler
* Context - Value passed to the handler on each GPE * Context - Value passed to the handler on each GPE
* *
* RETURN: Status * RETURN: Status
* *
* DESCRIPTION: Install a handler for notifies on an ACPI device * DESCRIPTION: Install a handler for notifications on an ACPI Device,
* ThermalZone, or Processor object.
*
* NOTES: The Root namespace object may have only one handler for each
* type of notify (System/Device). Device/Thermal/Processor objects
* may have one device notify handler, and multiple system notify
* handlers.
* *
******************************************************************************/ ******************************************************************************/
@ -79,10 +85,11 @@ AcpiInstallNotifyHandler (
ACPI_NOTIFY_HANDLER Handler, ACPI_NOTIFY_HANDLER Handler,
void *Context) void *Context)
{ {
ACPI_NAMESPACE_NODE *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Device);
ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_OPERAND_OBJECT *NotifyObj; ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_NAMESPACE_NODE *Node;
ACPI_STATUS Status; ACPI_STATUS Status;
UINT32 i;
ACPI_FUNCTION_TRACE (AcpiInstallNotifyHandler); ACPI_FUNCTION_TRACE (AcpiInstallNotifyHandler);
@ -90,8 +97,7 @@ AcpiInstallNotifyHandler (
/* Parameter validation */ /* Parameter validation */
if ((!Device) || if ((!Device) || (!Handler) || (!HandlerType) ||
(!Handler) ||
(HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE)) (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))
{ {
return_ACPI_STATUS (AE_BAD_PARAMETER); return_ACPI_STATUS (AE_BAD_PARAMETER);
@ -103,137 +109,126 @@ AcpiInstallNotifyHandler (
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* Convert and validate the device handle */
Node = AcpiNsValidateHandle (Device);
if (!Node)
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
/* /*
* Root Object: * Root Object:
* Registering a notify handler on the root object indicates that the * Registering a notify handler on the root object indicates that the
* caller wishes to receive notifications for all objects. Note that * caller wishes to receive notifications for all objects. Note that
* only one <external> global handler can be regsitered (per notify type). * only one global handler can be registered per notify type.
* Ensure that a handler is not already installed.
*/ */
if (Device == ACPI_ROOT_OBJECT) if (Device == ACPI_ROOT_OBJECT)
{ {
/* Make sure the handler is not already installed */ for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&
AcpiGbl_SystemNotify.Handler) ||
((HandlerType & ACPI_DEVICE_NOTIFY) &&
AcpiGbl_DeviceNotify.Handler))
{ {
Status = AE_ALREADY_EXISTS; if (HandlerType & (i+1))
goto UnlockAndExit; {
if (AcpiGbl_GlobalNotify[i].Handler)
{
Status = AE_ALREADY_EXISTS;
goto UnlockAndExit;
}
AcpiGbl_GlobalNotify[i].Handler = Handler;
AcpiGbl_GlobalNotify[i].Context = Context;
}
} }
if (HandlerType & ACPI_SYSTEM_NOTIFY) goto UnlockAndExit; /* Global notify handler installed, all done */
{
AcpiGbl_SystemNotify.Node = Node;
AcpiGbl_SystemNotify.Handler = Handler;
AcpiGbl_SystemNotify.Context = Context;
}
if (HandlerType & ACPI_DEVICE_NOTIFY)
{
AcpiGbl_DeviceNotify.Node = Node;
AcpiGbl_DeviceNotify.Handler = Handler;
AcpiGbl_DeviceNotify.Context = Context;
}
/* Global notify handler installed */
} }
/* /*
* All Other Objects: * All Other Objects:
* Caller will only receive notifications specific to the target object. * Caller will only receive notifications specific to the target
* Note that only certain object types can receive notifications. * object. Note that only certain object types are allowed to
* receive notifications.
*/ */
else
/* Are Notifies allowed on this object? */
if (!AcpiEvIsNotifyObject (Node))
{ {
/* Notifies allowed on this object? */ Status = AE_TYPE;
goto UnlockAndExit;
}
if (!AcpiEvIsNotifyObject (Node)) /* Check for an existing internal object, might not exist */
{
Status = AE_TYPE;
goto UnlockAndExit;
}
/* Check for an existing internal object */ ObjDesc = AcpiNsGetAttachedObject (Node);
if (!ObjDesc)
{
/* Create a new object */
ObjDesc = AcpiNsGetAttachedObject (Node); ObjDesc = AcpiUtCreateInternalObject (Node->Type);
if (ObjDesc) if (!ObjDesc)
{
/* Object exists - make sure there's no handler */
if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&
ObjDesc->CommonNotify.SystemNotify) ||
((HandlerType & ACPI_DEVICE_NOTIFY) &&
ObjDesc->CommonNotify.DeviceNotify))
{
Status = AE_ALREADY_EXISTS;
goto UnlockAndExit;
}
}
else
{
/* Create a new object */
ObjDesc = AcpiUtCreateInternalObject (Node->Type);
if (!ObjDesc)
{
Status = AE_NO_MEMORY;
goto UnlockAndExit;
}
/* Attach new object to the Node */
Status = AcpiNsAttachObject (Device, ObjDesc, Node->Type);
/* Remove local reference to the object */
AcpiUtRemoveReference (ObjDesc);
if (ACPI_FAILURE (Status))
{
goto UnlockAndExit;
}
}
/* Install the handler */
NotifyObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_NOTIFY);
if (!NotifyObj)
{ {
Status = AE_NO_MEMORY; Status = AE_NO_MEMORY;
goto UnlockAndExit; goto UnlockAndExit;
} }
NotifyObj->Notify.Node = Node; /* Attach new object to the Node, remove local reference */
NotifyObj->Notify.Handler = Handler;
NotifyObj->Notify.Context = Context;
if (HandlerType & ACPI_SYSTEM_NOTIFY) Status = AcpiNsAttachObject (Device, ObjDesc, Node->Type);
AcpiUtRemoveReference (ObjDesc);
if (ACPI_FAILURE (Status))
{ {
ObjDesc->CommonNotify.SystemNotify = NotifyObj; goto UnlockAndExit;
} }
}
if (HandlerType & ACPI_DEVICE_NOTIFY) /* Ensure that the handler is not already installed in the lists */
for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
{
if (HandlerType & (i+1))
{ {
ObjDesc->CommonNotify.DeviceNotify = NotifyObj; HandlerObj = ObjDesc->CommonNotify.NotifyList[i];
} while (HandlerObj)
{
if (HandlerObj->Notify.Handler == Handler)
{
Status = AE_ALREADY_EXISTS;
goto UnlockAndExit;
}
if (HandlerType == ACPI_ALL_NOTIFY) HandlerObj = HandlerObj->Notify.Next[i];
}
}
}
/* Create and populate a new notify handler object */
HandlerObj = AcpiUtCreateInternalObject (ACPI_TYPE_LOCAL_NOTIFY);
if (!HandlerObj)
{
Status = AE_NO_MEMORY;
goto UnlockAndExit;
}
HandlerObj->Notify.Node = Node;
HandlerObj->Notify.HandlerType = HandlerType;
HandlerObj->Notify.Handler = Handler;
HandlerObj->Notify.Context = Context;
/* Install the handler at the list head(s) */
for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
{
if (HandlerType & (i+1))
{ {
/* Extra ref if installed in both */ HandlerObj->Notify.Next[i] =
ObjDesc->CommonNotify.NotifyList[i];
AcpiUtAddReference (NotifyObj); ObjDesc->CommonNotify.NotifyList[i] = HandlerObj;
} }
} }
/* Add an extra reference if handler was installed in both lists */
if (HandlerType == ACPI_ALL_NOTIFY)
{
AcpiUtAddReference (HandlerObj);
}
UnlockAndExit: UnlockAndExit:
(void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE); (void) AcpiUtReleaseMutex (ACPI_MTX_NAMESPACE);
@ -247,11 +242,11 @@ ACPI_EXPORT_SYMBOL (AcpiInstallNotifyHandler)
* *
* FUNCTION: AcpiRemoveNotifyHandler * FUNCTION: AcpiRemoveNotifyHandler
* *
* PARAMETERS: Device - The device for which notifies will be handled * PARAMETERS: Device - The device for which the handler is installed
* HandlerType - The type of handler: * HandlerType - The type of handler:
* ACPI_SYSTEM_NOTIFY: SystemHandler (00-7f) * ACPI_SYSTEM_NOTIFY: System Handler (00-7F)
* ACPI_DEVICE_NOTIFY: DriverHandler (80-ff) * ACPI_DEVICE_NOTIFY: Device Handler (80-FF)
* ACPI_ALL_NOTIFY: both system and device * ACPI_ALL_NOTIFY: Both System and Device
* Handler - Address of the handler * Handler - Address of the handler
* *
* RETURN: Status * RETURN: Status
@ -266,10 +261,12 @@ AcpiRemoveNotifyHandler (
UINT32 HandlerType, UINT32 HandlerType,
ACPI_NOTIFY_HANDLER Handler) ACPI_NOTIFY_HANDLER Handler)
{ {
ACPI_OPERAND_OBJECT *NotifyObj; ACPI_NAMESPACE_NODE *Node = ACPI_CAST_PTR (ACPI_NAMESPACE_NODE, Device);
ACPI_OPERAND_OBJECT *ObjDesc; ACPI_OPERAND_OBJECT *ObjDesc;
ACPI_NAMESPACE_NODE *Node; ACPI_OPERAND_OBJECT *HandlerObj;
ACPI_OPERAND_OBJECT *PreviousHandlerObj;
ACPI_STATUS Status; ACPI_STATUS Status;
UINT32 i;
ACPI_FUNCTION_TRACE (AcpiRemoveNotifyHandler); ACPI_FUNCTION_TRACE (AcpiRemoveNotifyHandler);
@ -277,122 +274,105 @@ AcpiRemoveNotifyHandler (
/* Parameter validation */ /* Parameter validation */
if ((!Device) || if ((!Device) || (!Handler) || (!HandlerType) ||
(!Handler) ||
(HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE)) (HandlerType > ACPI_MAX_NOTIFY_HANDLER_TYPE))
{ {
return_ACPI_STATUS (AE_BAD_PARAMETER); return_ACPI_STATUS (AE_BAD_PARAMETER);
} }
#ifdef _UNDER_DEVELOPMENT
/* Make sure all deferred tasks are completed */
AcpiOsWaitEventsComplete (NULL);
#endif
Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE); Status = AcpiUtAcquireMutex (ACPI_MTX_NAMESPACE);
if (ACPI_FAILURE (Status)) if (ACPI_FAILURE (Status))
{ {
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
} }
/* Convert and validate the device handle */ /* Root Object. Global handlers are removed here */
Node = AcpiNsValidateHandle (Device);
if (!Node)
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
/* Root Object */
if (Device == ACPI_ROOT_OBJECT) if (Device == ACPI_ROOT_OBJECT)
{ {
ACPI_DEBUG_PRINT ((ACPI_DB_INFO, for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
"Removing notify handler for namespace root object\n"));
if (((HandlerType & ACPI_SYSTEM_NOTIFY) &&
!AcpiGbl_SystemNotify.Handler) ||
((HandlerType & ACPI_DEVICE_NOTIFY) &&
!AcpiGbl_DeviceNotify.Handler))
{ {
Status = AE_NOT_EXIST; if (HandlerType & (i+1))
goto UnlockAndExit; {
if (!AcpiGbl_GlobalNotify[i].Handler ||
(AcpiGbl_GlobalNotify[i].Handler != Handler))
{
Status = AE_NOT_EXIST;
goto UnlockAndExit;
}
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
"Removing global notify handler\n"));
AcpiGbl_GlobalNotify[i].Handler = NULL;
AcpiGbl_GlobalNotify[i].Context = NULL;
}
} }
if (HandlerType & ACPI_SYSTEM_NOTIFY) goto UnlockAndExit;
{
AcpiGbl_SystemNotify.Node = NULL;
AcpiGbl_SystemNotify.Handler = NULL;
AcpiGbl_SystemNotify.Context = NULL;
}
if (HandlerType & ACPI_DEVICE_NOTIFY)
{
AcpiGbl_DeviceNotify.Node = NULL;
AcpiGbl_DeviceNotify.Handler = NULL;
AcpiGbl_DeviceNotify.Context = NULL;
}
} }
/* All Other Objects */ /* All other objects: Are Notifies allowed on this object? */
else if (!AcpiEvIsNotifyObject (Node))
{ {
/* Notifies allowed on this object? */ Status = AE_TYPE;
goto UnlockAndExit;
}
if (!AcpiEvIsNotifyObject (Node)) /* Must have an existing internal object */
ObjDesc = AcpiNsGetAttachedObject (Node);
if (!ObjDesc)
{
Status = AE_NOT_EXIST;
goto UnlockAndExit;
}
/* Internal object exists. Find the handler and remove it */
for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
{
if (HandlerType & (i+1))
{ {
Status = AE_TYPE; HandlerObj = ObjDesc->CommonNotify.NotifyList[i];
goto UnlockAndExit; PreviousHandlerObj = NULL;
}
/* Check for an existing internal object */ /* Attempt to find the handler in the handler list */
ObjDesc = AcpiNsGetAttachedObject (Node); while (HandlerObj &&
if (!ObjDesc) (HandlerObj->Notify.Handler != Handler))
{ {
Status = AE_NOT_EXIST; PreviousHandlerObj = HandlerObj;
goto UnlockAndExit; HandlerObj = HandlerObj->Notify.Next[i];
} }
/* Object exists - make sure there's an existing handler */ if (!HandlerObj)
if (HandlerType & ACPI_SYSTEM_NOTIFY)
{
NotifyObj = ObjDesc->CommonNotify.SystemNotify;
if (!NotifyObj)
{ {
Status = AE_NOT_EXIST; Status = AE_NOT_EXIST;
goto UnlockAndExit; goto UnlockAndExit;
} }
if (NotifyObj->Notify.Handler != Handler) /* Remove the handler object from the list */
if (PreviousHandlerObj) /* Handler is not at the list head */
{ {
Status = AE_BAD_PARAMETER; PreviousHandlerObj->Notify.Next[i] =
goto UnlockAndExit; HandlerObj->Notify.Next[i];
}
else /* Handler is at the list head */
{
ObjDesc->CommonNotify.NotifyList[i] =
HandlerObj->Notify.Next[i];
} }
/* Remove the handler */ AcpiUtRemoveReference (HandlerObj);
ObjDesc->CommonNotify.SystemNotify = NULL;
AcpiUtRemoveReference (NotifyObj);
}
if (HandlerType & ACPI_DEVICE_NOTIFY)
{
NotifyObj = ObjDesc->CommonNotify.DeviceNotify;
if (!NotifyObj)
{
Status = AE_NOT_EXIST;
goto UnlockAndExit;
}
if (NotifyObj->Notify.Handler != Handler)
{
Status = AE_BAD_PARAMETER;
goto UnlockAndExit;
}
/* Remove the handler */
ObjDesc->CommonNotify.DeviceNotify = NULL;
AcpiUtRemoveReference (NotifyObj);
} }
} }

29
sys/contrib/dev/acpica/components/executer/exdump.c
View File

@ -131,8 +131,8 @@ static ACPI_EXDUMP_INFO AcpiExDumpDevice[4] =
{ {
{ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpDevice), NULL}, {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpDevice), NULL},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.Handler), "Handler"}, {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.Handler), "Handler"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.SystemNotify), "System Notify"}, {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.NotifyList[0]), "System Notify"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.DeviceNotify), "Device Notify"} {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Device.NotifyList[1]), "Device Notify"}
}; };
static ACPI_EXDUMP_INFO AcpiExDumpEvent[2] = static ACPI_EXDUMP_INFO AcpiExDumpEvent[2] =
@ -179,8 +179,8 @@ static ACPI_EXDUMP_INFO AcpiExDumpPower[5] =
{ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpPower), NULL}, {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpPower), NULL},
{ACPI_EXD_UINT32, ACPI_EXD_OFFSET (PowerResource.SystemLevel), "System Level"}, {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (PowerResource.SystemLevel), "System Level"},
{ACPI_EXD_UINT32, ACPI_EXD_OFFSET (PowerResource.ResourceOrder), "Resource Order"}, {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (PowerResource.ResourceOrder), "Resource Order"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.SystemNotify), "System Notify"}, {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.NotifyList[0]), "System Notify"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.DeviceNotify), "Device Notify"} {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (PowerResource.NotifyList[1]), "Device Notify"}
}; };
static ACPI_EXDUMP_INFO AcpiExDumpProcessor[7] = static ACPI_EXDUMP_INFO AcpiExDumpProcessor[7] =
@ -189,16 +189,16 @@ static ACPI_EXDUMP_INFO AcpiExDumpProcessor[7] =
{ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Processor.ProcId), "Processor ID"}, {ACPI_EXD_UINT8, ACPI_EXD_OFFSET (Processor.ProcId), "Processor ID"},
{ACPI_EXD_UINT8 , ACPI_EXD_OFFSET (Processor.Length), "Length"}, {ACPI_EXD_UINT8 , ACPI_EXD_OFFSET (Processor.Length), "Length"},
{ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET (Processor.Address), "Address"}, {ACPI_EXD_ADDRESS, ACPI_EXD_OFFSET (Processor.Address), "Address"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.SystemNotify), "System Notify"}, {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.NotifyList[0]), "System Notify"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.DeviceNotify), "Device Notify"}, {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.NotifyList[1]), "Device Notify"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.Handler), "Handler"} {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Processor.Handler), "Handler"}
}; };
static ACPI_EXDUMP_INFO AcpiExDumpThermal[4] = static ACPI_EXDUMP_INFO AcpiExDumpThermal[4] =
{ {
{ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpThermal), NULL}, {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpThermal), NULL},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.SystemNotify), "System Notify"}, {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.NotifyList[0]), "System Notify"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.DeviceNotify), "Device Notify"}, {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.NotifyList[1]), "Device Notify"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.Handler), "Handler"} {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (ThermalZone.Handler), "Handler"}
}; };
@ -258,11 +258,15 @@ static ACPI_EXDUMP_INFO AcpiExDumpAddressHandler[6] =
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (AddressSpace.Context), "Context"} {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (AddressSpace.Context), "Context"}
}; };
static ACPI_EXDUMP_INFO AcpiExDumpNotify[3] = static ACPI_EXDUMP_INFO AcpiExDumpNotify[7] =
{ {
{ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpNotify), NULL}, {ACPI_EXD_INIT, ACPI_EXD_TABLE_SIZE (AcpiExDumpNotify), NULL},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Node), "Node"}, {ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Node), "Node"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Context), "Context"} {ACPI_EXD_UINT32, ACPI_EXD_OFFSET (Notify.HandlerType), "Handler Type"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Handler), "Handler"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Context), "Context"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Next[0]), "Next System Notify"},
{ACPI_EXD_POINTER, ACPI_EXD_OFFSET (Notify.Next[1]), "Next Device Notify"}
}; };
@ -1001,10 +1005,7 @@ AcpiExDumpPackageObj (
case ACPI_TYPE_STRING: case ACPI_TYPE_STRING:
AcpiOsPrintf ("[String] Value: "); AcpiOsPrintf ("[String] Value: ");
for (i = 0; i < ObjDesc->String.Length; i++) AcpiUtPrintString (ObjDesc->String.Pointer, ACPI_UINT8_MAX);
{
AcpiOsPrintf ("%c", ObjDesc->String.Pointer[i]);
}
AcpiOsPrintf ("\n"); AcpiOsPrintf ("\n");
break; break;

8
sys/contrib/dev/acpica/components/hardware/hwesleep.c
View File

@ -132,7 +132,7 @@ AcpiHwExtendedSleep (
/* Clear wake status (WAK_STS) */ /* Clear wake status (WAK_STS) */
Status = AcpiWrite (ACPI_X_WAKE_STATUS, &AcpiGbl_FADT.SleepStatus); Status = AcpiWrite ((UINT64) ACPI_X_WAKE_STATUS, &AcpiGbl_FADT.SleepStatus);
if (ACPI_FAILURE (Status)) if (ACPI_FAILURE (Status))
{ {
return_ACPI_STATUS (Status); return_ACPI_STATUS (Status);
@ -163,7 +163,7 @@ AcpiHwExtendedSleep (
SleepTypeValue = ((AcpiGbl_SleepTypeA << ACPI_X_SLEEP_TYPE_POSITION) & SleepTypeValue = ((AcpiGbl_SleepTypeA << ACPI_X_SLEEP_TYPE_POSITION) &
ACPI_X_SLEEP_TYPE_MASK); ACPI_X_SLEEP_TYPE_MASK);
Status = AcpiWrite ((SleepTypeValue | ACPI_X_SLEEP_ENABLE), Status = AcpiWrite ((UINT64) (SleepTypeValue | ACPI_X_SLEEP_ENABLE),
&AcpiGbl_FADT.SleepControl); &AcpiGbl_FADT.SleepControl);
if (ACPI_FAILURE (Status)) if (ACPI_FAILURE (Status))
{ {
@ -219,7 +219,7 @@ AcpiHwExtendedWakePrep (
SleepTypeValue = ((AcpiGbl_SleepTypeA << ACPI_X_SLEEP_TYPE_POSITION) & SleepTypeValue = ((AcpiGbl_SleepTypeA << ACPI_X_SLEEP_TYPE_POSITION) &
ACPI_X_SLEEP_TYPE_MASK); ACPI_X_SLEEP_TYPE_MASK);
(void) AcpiWrite ((SleepTypeValue | ACPI_X_SLEEP_ENABLE), (void) AcpiWrite ((UINT64) (SleepTypeValue | ACPI_X_SLEEP_ENABLE),
&AcpiGbl_FADT.SleepControl); &AcpiGbl_FADT.SleepControl);
} }
@ -269,7 +269,7 @@ AcpiHwExtendedWake (
* and use it to determine whether the system is rebooting or * and use it to determine whether the system is rebooting or
* resuming. Clear WAK_STS for compatibility. * resuming. Clear WAK_STS for compatibility.
*/ */
(void) AcpiWrite (ACPI_X_WAKE_STATUS, &AcpiGbl_FADT.SleepStatus); (void) AcpiWrite ((UINT64) ACPI_X_WAKE_STATUS, &AcpiGbl_FADT.SleepStatus);
AcpiGbl_SystemAwakeAndRunning = TRUE; AcpiGbl_SystemAwakeAndRunning = TRUE;
AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WORKING); AcpiHwExecuteSleepMethod (METHOD_PATHNAME__SST, ACPI_SST_WORKING);

21
sys/contrib/dev/acpica/components/utilities/utdelete.c
View File

@ -167,7 +167,7 @@ AcpiUtDeleteInternalObj (
case ACPI_TYPE_PROCESSOR: case ACPI_TYPE_PROCESSOR:
case ACPI_TYPE_THERMAL: case ACPI_TYPE_THERMAL:
/* Walk the notify handler list for this object */ /* Walk the address handler list for this object */
HandlerDesc = Object->CommonNotify.Handler; HandlerDesc = Object->CommonNotify.Handler;
while (HandlerDesc) while (HandlerDesc)
@ -523,6 +523,7 @@ AcpiUtUpdateObjectReference (
ACPI_STATUS Status = AE_OK; ACPI_STATUS Status = AE_OK;
ACPI_GENERIC_STATE *StateList = NULL; ACPI_GENERIC_STATE *StateList = NULL;
ACPI_OPERAND_OBJECT *NextObject = NULL; ACPI_OPERAND_OBJECT *NextObject = NULL;
ACPI_OPERAND_OBJECT *PrevObject;
ACPI_GENERIC_STATE *State; ACPI_GENERIC_STATE *State;
UINT32 i; UINT32 i;
@ -552,10 +553,20 @@ AcpiUtUpdateObjectReference (
case ACPI_TYPE_POWER: case ACPI_TYPE_POWER:
case ACPI_TYPE_THERMAL: case ACPI_TYPE_THERMAL:
/* Update the notify objects for these types (if present) */ /*
* Update the notify objects for these types (if present)
AcpiUtUpdateRefCount (Object->CommonNotify.SystemNotify, Action); * Two lists, system and device notify handlers.
AcpiUtUpdateRefCount (Object->CommonNotify.DeviceNotify, Action); */
for (i = 0; i < ACPI_NUM_NOTIFY_TYPES; i++)
{
PrevObject = Object->CommonNotify.NotifyList[i];
while (PrevObject)
{
NextObject = PrevObject->Notify.Next[i];
AcpiUtUpdateRefCount (PrevObject, Action);
PrevObject = NextObject;
}
}
break; break;
case ACPI_TYPE_PACKAGE: case ACPI_TYPE_PACKAGE:

4
sys/contrib/dev/acpica/components/utilities/utglobal.c
View File

@ -287,8 +287,8 @@ AcpiUtInitGlobals (
/* Global handlers */ /* Global handlers */
AcpiGbl_SystemNotify.Handler = NULL; AcpiGbl_GlobalNotify[0].Handler = NULL;
AcpiGbl_DeviceNotify.Handler = NULL; AcpiGbl_GlobalNotify[1].Handler = NULL;
AcpiGbl_ExceptionHandler = NULL; AcpiGbl_ExceptionHandler = NULL;
AcpiGbl_InitHandler = NULL; AcpiGbl_InitHandler = NULL;
AcpiGbl_TableHandler = NULL; AcpiGbl_TableHandler = NULL;

6
sys/contrib/dev/acpica/components/utilities/uttrack.c
View File

@ -633,21 +633,21 @@ AcpiUtDumpAllocations (
switch (ACPI_GET_DESCRIPTOR_TYPE (Descriptor)) switch (ACPI_GET_DESCRIPTOR_TYPE (Descriptor))
{ {
case ACPI_DESC_TYPE_OPERAND: case ACPI_DESC_TYPE_OPERAND:
if (Element->Size == sizeof (ACPI_DESC_TYPE_OPERAND)) if (Element->Size == sizeof (ACPI_OPERAND_OBJECT))
{ {
DescriptorType = ACPI_DESC_TYPE_OPERAND; DescriptorType = ACPI_DESC_TYPE_OPERAND;
} }
break; break;
case ACPI_DESC_TYPE_PARSER: case ACPI_DESC_TYPE_PARSER:
if (Element->Size == sizeof (ACPI_DESC_TYPE_PARSER)) if (Element->Size == sizeof (ACPI_PARSE_OBJECT))
{ {
DescriptorType = ACPI_DESC_TYPE_PARSER; DescriptorType = ACPI_DESC_TYPE_PARSER;
} }
break; break;
case ACPI_DESC_TYPE_NAMED: case ACPI_DESC_TYPE_NAMED:
if (Element->Size == sizeof (ACPI_DESC_TYPE_NAMED)) if (Element->Size == sizeof (ACPI_NAMESPACE_NODE))
{ {
DescriptorType = ACPI_DESC_TYPE_NAMED; DescriptorType = ACPI_DESC_TYPE_NAMED;
} }

3
sys/contrib/dev/acpica/include/acglobal.h
View File

@ -254,8 +254,7 @@ ACPI_EXTERN ACPI_CACHE_T *AcpiGbl_OperandCache;
/* Global handlers */ /* Global handlers */
ACPI_EXTERN ACPI_OBJECT_NOTIFY_HANDLER AcpiGbl_DeviceNotify; ACPI_EXTERN ACPI_GLOBAL_NOTIFY_HANDLER AcpiGbl_GlobalNotify[2];
ACPI_EXTERN ACPI_OBJECT_NOTIFY_HANDLER AcpiGbl_SystemNotify;
ACPI_EXTERN ACPI_EXCEPTION_HANDLER AcpiGbl_ExceptionHandler; ACPI_EXTERN ACPI_EXCEPTION_HANDLER AcpiGbl_ExceptionHandler;
ACPI_EXTERN ACPI_INIT_HANDLER AcpiGbl_InitHandler; ACPI_EXTERN ACPI_INIT_HANDLER AcpiGbl_InitHandler;
ACPI_EXTERN ACPI_TABLE_HANDLER AcpiGbl_TableHandler; ACPI_EXTERN ACPI_TABLE_HANDLER AcpiGbl_TableHandler;

13
sys/contrib/dev/acpica/include/aclocal.h
View File

@ -716,6 +716,15 @@ ACPI_STATUS (*ACPI_PARSE_UPWARDS) (
struct acpi_walk_state *WalkState); struct acpi_walk_state *WalkState);
/* Global handlers for AML Notifies */
typedef struct acpi_global_notify_handler
{
ACPI_NOTIFY_HANDLER Handler;
void *Context;
} ACPI_GLOBAL_NOTIFY_HANDLER;
/* /*
* Notify info - used to pass info to the deferred notify * Notify info - used to pass info to the deferred notify
* handler/dispatcher. * handler/dispatcher.
@ -723,8 +732,10 @@ ACPI_STATUS (*ACPI_PARSE_UPWARDS) (
typedef struct acpi_notify_info typedef struct acpi_notify_info
{ {
ACPI_STATE_COMMON ACPI_STATE_COMMON
UINT8 HandlerListId;
ACPI_NAMESPACE_NODE *Node; ACPI_NAMESPACE_NODE *Node;
union acpi_operand_object *HandlerObj; union acpi_operand_object *HandlerListHead;
ACPI_GLOBAL_NOTIFY_HANDLER *Global;
} ACPI_NOTIFY_INFO; } ACPI_NOTIFY_INFO;

7
sys/contrib/dev/acpica/include/acobject.h
View File

@ -246,8 +246,7 @@ typedef struct acpi_object_method
* Common fields for objects that support ASL notifications * Common fields for objects that support ASL notifications
*/ */
#define ACPI_COMMON_NOTIFY_INFO \ #define ACPI_COMMON_NOTIFY_INFO \
union acpi_operand_object *SystemNotify; /* Handler for system notifies */\ union acpi_operand_object *NotifyList[2]; /* Handlers for system/device notifies */\
union acpi_operand_object *DeviceNotify; /* Handler for driver notifies */\
union acpi_operand_object *Handler; /* Handler for Address space */ union acpi_operand_object *Handler; /* Handler for Address space */
@ -389,8 +388,10 @@ typedef struct acpi_object_notify_handler
{ {
ACPI_OBJECT_COMMON_HEADER ACPI_OBJECT_COMMON_HEADER
ACPI_NAMESPACE_NODE *Node; /* Parent device */ ACPI_NAMESPACE_NODE *Node; /* Parent device */
ACPI_NOTIFY_HANDLER Handler; UINT32 HandlerType; /* Type: Device/System/Both */
ACPI_NOTIFY_HANDLER Handler; /* Handler addess */
void *Context; void *Context;
union acpi_operand_object *Next[2]; /* Device and System handler lists */
} ACPI_OBJECT_NOTIFY_HANDLER; } ACPI_OBJECT_NOTIFY_HANDLER;

2
sys/contrib/dev/acpica/include/acpixf.h
View File

@ -48,7 +48,7 @@
/* Current ACPICA subsystem version in YYYYMMDD format */ /* Current ACPICA subsystem version in YYYYMMDD format */
#define ACPI_CA_VERSION 0x20120320 #define ACPI_CA_VERSION 0x20120420
#include <contrib/dev/acpica/include/acconfig.h> #include <contrib/dev/acpica/include/acconfig.h>
#include <contrib/dev/acpica/include/actypes.h> #include <contrib/dev/acpica/include/actypes.h>

4
sys/contrib/dev/acpica/include/actypes.h
View File

@ -708,10 +708,14 @@ typedef UINT32 ACPI_EVENT_STATUS;
#define ACPI_DEVICE_NOTIFY 0x2 #define ACPI_DEVICE_NOTIFY 0x2
#define ACPI_ALL_NOTIFY (ACPI_SYSTEM_NOTIFY | ACPI_DEVICE_NOTIFY) #define ACPI_ALL_NOTIFY (ACPI_SYSTEM_NOTIFY | ACPI_DEVICE_NOTIFY)
#define ACPI_MAX_NOTIFY_HANDLER_TYPE 0x3 #define ACPI_MAX_NOTIFY_HANDLER_TYPE 0x3
#define ACPI_NUM_NOTIFY_TYPES 2
#define ACPI_MAX_SYS_NOTIFY 0x7F #define ACPI_MAX_SYS_NOTIFY 0x7F
#define ACPI_MAX_DEVICE_SPECIFIC_NOTIFY 0xBF #define ACPI_MAX_DEVICE_SPECIFIC_NOTIFY 0xBF
#define ACPI_SYSTEM_HANDLER_LIST 0 /* Used as index, must be SYSTEM_NOTIFY -1 */
#define ACPI_DEVICE_HANDLER_LIST 1 /* Used as index, must be DEVICE_NOTIFY -1 */
/* Address Space (Operation Region) Types */ /* Address Space (Operation Region) Types */

5
usr.sbin/acpi/iasl/Makefile
View File

@ -73,8 +73,9 @@ CLEANFILES= aslcompiler.y.h aslcompilerlex.c aslcompilerparse.c \
aslcompilerparse.h dtparser.y.h dtparserlex.c \ aslcompilerparse.h dtparser.y.h dtparserlex.c \
dtparserparse.c dtparserparse.h dtparserparse.c dtparserparse.h
aslcompilerlex.c: aslcompiler.l aslcompilerlex.c: aslcompiler.l aslsupport.l
${LEX} ${LFLAGS} -PAslCompiler -o${.TARGET} ${.ALLSRC} ${LEX} ${LFLAGS} -PAslCompiler -o${.TARGET} \
${ACPICA_DIR}/compiler/aslcompiler.l
.ORDER: aslcompilerparse.c aslcompilerparse.h .ORDER: aslcompilerparse.c aslcompilerparse.h
aslcompilerparse.c aslcompilerparse.h: aslcompiler.y aslcompilerparse.c aslcompilerparse.h: aslcompiler.y