| Current Path : /sys/amd64/compile/hs32/modules/usr/src/sys/modules/usb/urio/@/amd64/compile/hs32/modules/usr/src/sys/modules/fdescfs/@/contrib/dev/acpica/compiler/ |
FreeBSD hs32.drive.ne.jp 9.1-RELEASE FreeBSD 9.1-RELEASE #1: Wed Jan 14 12:18:08 JST 2015 root@hs32.drive.ne.jp:/sys/amd64/compile/hs32 amd64 |
| Current File : //sys/amd64/compile/hs32/modules/usr/src/sys/modules/usb/urio/@/amd64/compile/hs32/modules/usr/src/sys/modules/fdescfs/@/contrib/dev/acpica/compiler/dtio.c |
/******************************************************************************
*
* Module Name: dtio.c - File I/O support for data table compiler
*
*****************************************************************************/
/*
* Copyright (C) 2000 - 2011, 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.
*/
#define __DTIO_C__
#include <contrib/dev/acpica/compiler/aslcompiler.h>
#include <contrib/dev/acpica/compiler/dtcompiler.h>
#define _COMPONENT DT_COMPILER
ACPI_MODULE_NAME ("dtio")
/* Local prototypes */
static char *
DtTrim (
char *String);
static void
DtLinkField (
DT_FIELD *Field);
static ACPI_STATUS
DtParseLine (
char *LineBuffer,
UINT32 Line,
UINT32 Offset);
UINT32
DtGetNextLine (
FILE *Handle);
static void
DtWriteBinary (
DT_SUBTABLE *Subtable,
void *Context,
void *ReturnValue);
static void
DtDumpBuffer (
UINT32 FileId,
UINT8 *Buffer,
UINT32 Offset,
UINT32 Length);
/* States for DtGetNextLine */
#define DT_NORMAL_TEXT 0
#define DT_START_QUOTED_STRING 1
#define DT_START_COMMENT 2
#define DT_SLASH_ASTERISK_COMMENT 3
#define DT_SLASH_SLASH_COMMENT 4
#define DT_END_COMMENT 5
#define DT_MERGE_LINES 6
static UINT32 Gbl_NextLineOffset;
/******************************************************************************
*
* FUNCTION: DtTrim
*
* PARAMETERS: String - Current source code line to trim
*
* RETURN: Trimmed line. Must be freed by caller.
*
* DESCRIPTION: Trim left and right spaces
*
*****************************************************************************/
static char *
DtTrim (
char *String)
{
char *Start;
char *End;
char *ReturnString;
ACPI_SIZE Length;
/* Skip lines that start with a space */
if (!ACPI_STRCMP (String, " "))
{
ReturnString = UtLocalCalloc (1);
return (ReturnString);
}
/* Setup pointers to start and end of input string */
Start = String;
End = String + ACPI_STRLEN (String) - 1;
/* Find first non-whitespace character */
while ((Start <= End) && ((*Start == ' ') || (*Start == '\t')))
{
Start++;
}
/* Find last non-space character */
while (End >= Start)
{
if (*End == '\r' || *End == '\n')
{
End--;
continue;
}
if (*End != ' ')
{
break;
}
End--;
}
/* Remove any quotes around the string */
if (*Start == '\"')
{
Start++;
}
if (*End == '\"')
{
End--;
}
/* Create the trimmed return string */
Length = ACPI_PTR_DIFF (End, Start) + 1;
ReturnString = UtLocalCalloc (Length + 1);
if (ACPI_STRLEN (Start))
{
ACPI_STRNCPY (ReturnString, Start, Length);
}
ReturnString[Length] = 0;
return (ReturnString);
}
/******************************************************************************
*
* FUNCTION: DtLinkField
*
* PARAMETERS: Field - New field object to link
*
* RETURN: None
*
* DESCRIPTION: Link one field name and value to the list
*
*****************************************************************************/
static void
DtLinkField (
DT_FIELD *Field)
{
DT_FIELD *Prev;
DT_FIELD *Next;
Prev = Next = Gbl_FieldList;
while (Next)
{
Prev = Next;
Next = Next->Next;
}
if (Prev)
{
Prev->Next = Field;
}
else
{
Gbl_FieldList = Field;
}
}
/******************************************************************************
*
* FUNCTION: DtParseLine
*
* PARAMETERS: LineBuffer - Current source code line
* Line - Current line number in the source
* Offset - Current byte offset of the line
*
* RETURN: Status
*
* DESCRIPTION: Parse one source line
*
*****************************************************************************/
static ACPI_STATUS
DtParseLine (
char *LineBuffer,
UINT32 Line,
UINT32 Offset)
{
char *Start;
char *End;
char *TmpName;
char *TmpValue;
char *Name;
char *Value;
char *Colon;
UINT32 Length;
DT_FIELD *Field;
UINT32 Column;
UINT32 NameColumn;
BOOLEAN IsNullString = FALSE;
if (!LineBuffer)
{
return (AE_OK);
}
/* All lines after "Raw Table Data" are ingored */
if (strstr (LineBuffer, ACPI_RAW_TABLE_DATA_HEADER))
{
return (AE_NOT_FOUND);
}
Colon = strchr (LineBuffer, ':');
if (!Colon)
{
return (AE_OK);
}
Start = LineBuffer;
End = Colon;
while (Start < Colon)
{
if (*Start == ' ')
{
Start++;
continue;
}
/* Found left bracket, go to the right bracket */
if (*Start == '[')
{
while (Start < Colon && *Start != ']')
{
Start++;
}
if (Start == Colon)
{
break;
}
Start++;
continue;
}
break;
}
/*
* There are two column values. One for the field name,
* and one for the field value.
*/
Column = ACPI_PTR_DIFF (Colon, LineBuffer) + 3;
NameColumn = ACPI_PTR_DIFF (Start, LineBuffer) + 1;
Length = ACPI_PTR_DIFF (End, Start);
TmpName = UtLocalCalloc (Length + 1);
ACPI_STRNCPY (TmpName, Start, Length);
Name = DtTrim (TmpName);
ACPI_FREE (TmpName);
Start = End = (Colon + 1);
while (*End)
{
/* Found left quotation, go to the right quotation and break */
if (*End == '"')
{
End++;
/* Check for an explicit null string */
if (*End == '"')
{
IsNullString = TRUE;
}
while (*End && (*End != '"'))
{
End++;
}
End++;
break;
}
/*
* Special "comment" fields at line end, ignore them.
* Note: normal slash-slash and slash-asterisk comments are
* stripped already by the DtGetNextLine parser.
*
* TBD: Perhaps DtGetNextLine should parse the following type
* of comments also.
*/
if (*End == '[')
{
End--;
break;
}
End++;
}
Length = ACPI_PTR_DIFF (End, Start);
TmpValue = UtLocalCalloc (Length + 1);
ACPI_STRNCPY (TmpValue, Start, Length);
Value = DtTrim (TmpValue);
ACPI_FREE (TmpValue);
/* Create a new field object only if we have a valid value field */
if ((Value && *Value) || IsNullString)
{
Field = UtLocalCalloc (sizeof (DT_FIELD));
Field->Name = Name;
Field->Value = Value;
Field->Line = Line;
Field->ByteOffset = Offset;
Field->NameColumn = NameColumn;
Field->Column = Column;
DtLinkField (Field);
}
else /* Ignore this field, it has no valid data */
{
ACPI_FREE (Name);
ACPI_FREE (Value);
}
return (AE_OK);
}
/******************************************************************************
*
* FUNCTION: DtGetNextLine
*
* PARAMETERS: Handle - Open file handle for the source file
*
* RETURN: Filled line buffer and offset of start-of-line (ASL_EOF on EOF)
*
* DESCRIPTION: Get the next valid source line. Removes all comments.
* Ignores empty lines.
*
* Handles both slash-asterisk and slash-slash comments.
* Also, quoted strings, but no escapes within.
*
* Line is returned in Gbl_CurrentLineBuffer.
* Line number in original file is returned in Gbl_CurrentLineNumber.
*
*****************************************************************************/
UINT32
DtGetNextLine (
FILE *Handle)
{
BOOLEAN LineNotAllBlanks = FALSE;
UINT32 State = DT_NORMAL_TEXT;
UINT32 CurrentLineOffset;
UINT32 i;
char c;
for (i = 0; i < ASL_LINE_BUFFER_SIZE;)
{
c = (char) getc (Handle);
if (c == EOF)
{
switch (State)
{
case DT_START_QUOTED_STRING:
case DT_SLASH_ASTERISK_COMMENT:
case DT_SLASH_SLASH_COMMENT:
AcpiOsPrintf ("**** EOF within comment/string %u\n", State);
break;
default:
break;
}
return (ASL_EOF);
}
switch (State)
{
case DT_NORMAL_TEXT:
/* Normal text, insert char into line buffer */
Gbl_CurrentLineBuffer[i] = c;
switch (c)
{
case '/':
State = DT_START_COMMENT;
break;
case '"':
State = DT_START_QUOTED_STRING;
LineNotAllBlanks = TRUE;
i++;
break;
case '\\':
/*
* The continuation char MUST be last char on this line.
* Otherwise, it will be assumed to be a valid ASL char.
*/
State = DT_MERGE_LINES;
break;
case '\n':
CurrentLineOffset = Gbl_NextLineOffset;
Gbl_NextLineOffset = (UINT32) ftell (Handle);
Gbl_CurrentLineNumber++;
/*
* Exit if line is complete. Ignore empty lines (only \n)
* or lines that contain nothing but blanks.
*/
if ((i != 0) && LineNotAllBlanks)
{
Gbl_CurrentLineBuffer[i+1] = 0; /* Terminate string */
return (CurrentLineOffset);
}
/* Toss this line and start a new one */
i = 0;
LineNotAllBlanks = FALSE;
break;
default:
if (c != ' ')
{
LineNotAllBlanks = TRUE;
}
i++;
break;
}
break;
case DT_START_QUOTED_STRING:
/* Insert raw chars until end of quoted string */
Gbl_CurrentLineBuffer[i] = c;
i++;
if (c == '"')
{
State = DT_NORMAL_TEXT;
}
break;
case DT_START_COMMENT:
/* Open comment if this character is an asterisk or slash */
switch (c)
{
case '*':
State = DT_SLASH_ASTERISK_COMMENT;
break;
case '/':
State = DT_SLASH_SLASH_COMMENT;
break;
default: /* Not a comment */
i++; /* Save the preceeding slash */
Gbl_CurrentLineBuffer[i] = c;
i++;
State = DT_NORMAL_TEXT;
break;
}
break;
case DT_SLASH_ASTERISK_COMMENT:
/* Ignore chars until an asterisk-slash is found */
switch (c)
{
case '\n':
Gbl_NextLineOffset = (UINT32) ftell (Handle);
Gbl_CurrentLineNumber++;
break;
case '*':
State = DT_END_COMMENT;
break;
default:
break;
}
break;
case DT_SLASH_SLASH_COMMENT:
/* Ignore chars until end-of-line */
if (c == '\n')
{
/* We will exit via the NORMAL_TEXT path */
ungetc (c, Handle);
State = DT_NORMAL_TEXT;
}
break;
case DT_END_COMMENT:
/* End comment if this char is a slash */
switch (c)
{
case '/':
State = DT_NORMAL_TEXT;
break;
case '\n':
CurrentLineOffset = Gbl_NextLineOffset;
Gbl_NextLineOffset = (UINT32) ftell (Handle);
Gbl_CurrentLineNumber++;
break;
case '*':
/* Consume all adjacent asterisks */
break;
default:
State = DT_SLASH_ASTERISK_COMMENT;
break;
}
break;
case DT_MERGE_LINES:
if (c != '\n')
{
/*
* This is not a continuation backslash, it is a normal
* normal ASL backslash - for example: Scope(\_SB_)
*/
i++; /* Keep the backslash that is already in the buffer */
ungetc (c, Handle);
State = DT_NORMAL_TEXT;
}
else
{
/*
* This is a continuation line -- a backlash followed
* immediately by a newline. Insert a space between the
* lines (overwrite the backslash)
*/
Gbl_CurrentLineBuffer[i] = ' ';
i++;
/* Ignore newline, this will merge the lines */
CurrentLineOffset = Gbl_NextLineOffset;
Gbl_NextLineOffset = (UINT32) ftell (Handle);
Gbl_CurrentLineNumber++;
State = DT_NORMAL_TEXT;
}
break;
default:
DtFatal (ASL_MSG_COMPILER_INTERNAL, NULL, "Unknown input state");
return (ASL_EOF);
}
}
printf ("ERROR - Input line is too long (max %u)\n", ASL_LINE_BUFFER_SIZE);
return (ASL_EOF);
}
/******************************************************************************
*
* FUNCTION: DtScanFile
*
* PARAMETERS: Handle - Open file handle for the source file
*
* RETURN: Pointer to start of the constructed parse tree.
*
* DESCRIPTION: Scan source file, link all field names and values
* to the global parse tree: Gbl_FieldList
*
*****************************************************************************/
DT_FIELD *
DtScanFile (
FILE *Handle)
{
ACPI_STATUS Status;
UINT32 Offset;
DT_FIELD *Next;
ACPI_FUNCTION_NAME (DtScanFile);
/* Get the file size */
Gbl_InputByteCount = DtGetFileSize (Handle);
Gbl_CurrentLineNumber = 0;
Gbl_CurrentLineOffset = 0;
Gbl_NextLineOffset = 0;
/* Scan line-by-line */
while ((Offset = DtGetNextLine (Handle)) != ASL_EOF)
{
ACPI_DEBUG_PRINT ((ACPI_DB_PARSE, "Line %2.2u/%4.4X - %s",
Gbl_CurrentLineNumber, Offset, Gbl_CurrentLineBuffer));
Status = DtParseLine (Gbl_CurrentLineBuffer, Gbl_CurrentLineNumber, Offset);
if (Status == AE_NOT_FOUND)
{
break;
}
}
/* Dump the parse tree if debug enabled */
if (Gbl_DebugFlag)
{
Next = Gbl_FieldList;
DbgPrint (ASL_DEBUG_OUTPUT, "Tree: %32s %32s %8s %8s %8s %8s %8s %8s\n\n",
"Name", "Value", "Line", "ByteOff", "NameCol", "Column", "TableOff", "Flags");
while (Next)
{
DbgPrint (ASL_DEBUG_OUTPUT, "Field: %32.32s %32.32s %.8X %.8X %.8X %.8X %.8X %.8X\n",
Next->Name,
Next->Value,
Next->Line,
Next->ByteOffset,
Next->NameColumn,
Next->Column,
Next->TableOffset,
Next->Flags);
Next = Next->Next;
}
}
return (Gbl_FieldList);
}
/*
* Output functions
*/
/******************************************************************************
*
* FUNCTION: DtWriteBinary
*
* PARAMETERS: DT_WALK_CALLBACK
*
* RETURN: Status
*
* DESCRIPTION: Write one subtable of a binary ACPI table
*
*****************************************************************************/
static void
DtWriteBinary (
DT_SUBTABLE *Subtable,
void *Context,
void *ReturnValue)
{
FlWriteFile (ASL_FILE_AML_OUTPUT, Subtable->Buffer, Subtable->Length);
}
/******************************************************************************
*
* FUNCTION: DtOutputBinary
*
* PARAMETERS:
*
* RETURN: Status
*
* DESCRIPTION: Write entire binary ACPI table (result of compilation)
*
*****************************************************************************/
void
DtOutputBinary (
DT_SUBTABLE *RootTable)
{
if (!RootTable)
{
return;
}
/* Walk the entire parse tree, emitting the binary data */
DtWalkTableTree (RootTable, DtWriteBinary, NULL, NULL);
Gbl_TableLength = DtGetFileSize (Gbl_Files[ASL_FILE_AML_OUTPUT].Handle);
}
/*
* Listing support
*/
/******************************************************************************
*
* FUNCTION: DtDumpBuffer
*
* PARAMETERS: FileID - Where to write buffer data
* Buffer - Buffer to dump
* Offset - Offset in current table
* Length - Buffer Length
*
* RETURN: None
*
* DESCRIPTION: Another copy of DumpBuffer routine (unfortunately).
*
* TBD: merge dump buffer routines
*
*****************************************************************************/
static void
DtDumpBuffer (
UINT32 FileId,
UINT8 *Buffer,
UINT32 Offset,
UINT32 Length)
{
UINT32 i;
UINT32 j;
UINT8 BufChar;
FlPrintFile (FileId, "Output: [%3.3Xh %4.4d %3d] ",
Offset, Offset, Length);
i = 0;
while (i < Length)
{
if (i >= 16)
{
FlPrintFile (FileId, "%24s", "");
}
/* Print 16 hex chars */
for (j = 0; j < 16;)
{
if (i + j >= Length)
{
/* Dump fill spaces */
FlPrintFile (FileId, " ");
j++;
continue;
}
FlPrintFile (FileId, "%02X ", Buffer[i+j]);
j++;
}
FlPrintFile (FileId, " ");
for (j = 0; j < 16; j++)
{
if (i + j >= Length)
{
FlPrintFile (FileId, "\n\n");
return;
}
BufChar = Buffer[(ACPI_SIZE) i + j];
if (ACPI_IS_PRINT (BufChar))
{
FlPrintFile (FileId, "%c", BufChar);
}
else
{
FlPrintFile (FileId, ".");
}
}
/* Done with that line. */
FlPrintFile (FileId, "\n");
i += 16;
}
FlPrintFile (FileId, "\n\n");
}
/******************************************************************************
*
* FUNCTION: DtWriteFieldToListing
*
* PARAMETERS: Buffer - Contains the compiled data
* Field - Field node for the input line
* Length - Length of the output data
*
* RETURN: None
*
* DESCRIPTION: Write one field to the listing file (if listing is enabled).
*
*****************************************************************************/
void
DtWriteFieldToListing (
UINT8 *Buffer,
DT_FIELD *Field,
UINT32 Length)
{
UINT8 FileByte;
if (!Gbl_ListingFlag || !Field)
{
return;
}
/* Dump the original source line */
FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Input: ");
FlSeekFile (ASL_FILE_INPUT, Field->ByteOffset);
while (FlReadFile (ASL_FILE_INPUT, &FileByte, 1) == AE_OK)
{
FlWriteFile (ASL_FILE_LISTING_OUTPUT, &FileByte, 1);
if (FileByte == '\n')
{
break;
}
}
/* Dump the line as parsed and represented internally */
FlPrintFile (ASL_FILE_LISTING_OUTPUT, "Parsed: %*s : %.64s",
Field->Column-4, Field->Name, Field->Value);
if (strlen (Field->Value) > 64)
{
FlPrintFile (ASL_FILE_LISTING_OUTPUT, "...Additional data, length 0x%X\n",
strlen (Field->Value));
}
FlPrintFile (ASL_FILE_LISTING_OUTPUT, "\n");
/* Dump the hex data that will be output for this field */
DtDumpBuffer (ASL_FILE_LISTING_OUTPUT, Buffer, Field->TableOffset, Length);
}
/******************************************************************************
*
* FUNCTION: DtWriteTableToListing
*
* PARAMETERS: None
*
* RETURN: None
*
* DESCRIPTION: Write the entire compiled table to the listing file
* in hex format
*
*****************************************************************************/
void
DtWriteTableToListing (
void)
{
UINT8 *Buffer;
if (!Gbl_ListingFlag)
{
return;
}
/* Read the entire table from the output file */
Buffer = UtLocalCalloc (Gbl_TableLength);
FlSeekFile (ASL_FILE_AML_OUTPUT, 0);
FlReadFile (ASL_FILE_AML_OUTPUT, Buffer, Gbl_TableLength);
/* Dump the raw table data */
AcpiOsRedirectOutput (Gbl_Files[ASL_FILE_LISTING_OUTPUT].Handle);
AcpiOsPrintf ("\n%s: Length %d (0x%X)\n\n",
ACPI_RAW_TABLE_DATA_HEADER, Gbl_TableLength, Gbl_TableLength);
AcpiUtDumpBuffer2 (Buffer, Gbl_TableLength, DB_BYTE_DISPLAY);
AcpiOsRedirectOutput (stdout);
}