summaryrefslogtreecommitdiff
path: root/source/tools/acpisrc
diff options
context:
space:
mode:
Diffstat (limited to 'source/tools/acpisrc')
-rw-r--r--source/tools/acpisrc/Makefile124
-rw-r--r--source/tools/acpisrc/acpisrc.h405
-rw-r--r--source/tools/acpisrc/ascase.c574
-rw-r--r--source/tools/acpisrc/asconvrt.c1448
-rw-r--r--source/tools/acpisrc/asfile.c815
-rw-r--r--source/tools/acpisrc/asmain.c457
-rw-r--r--source/tools/acpisrc/asremove.c616
-rw-r--r--source/tools/acpisrc/astable.c870
-rw-r--r--source/tools/acpisrc/asutils.c234
9 files changed, 5543 insertions, 0 deletions
diff --git a/source/tools/acpisrc/Makefile b/source/tools/acpisrc/Makefile
new file mode 100644
index 0000000000000..58a8654e350c0
--- /dev/null
+++ b/source/tools/acpisrc/Makefile
@@ -0,0 +1,124 @@
+#
+# acpisrc - ACPICA source code conversion utility
+#
+# NOTE: This makefile is intended to be used in the Linux environment,
+# with the Linux directory structure. It will not work directly
+# on the native ACPICA source tree.
+#
+
+#
+# Configuration
+# Notes:
+# gcc should be version 4 or greater, otherwise some of the options
+# used will not be recognized.
+# Global optimization flags (such as -O2, -Os) are not used, since
+# they cause issues on some compilers.
+# The _GNU_SOURCE symbol is required for many hosts.
+#
+PROG = acpisrc
+
+HOST = _LINUX
+NOMAN = YES
+COMPILE = $(CC) -c $(CFLAGS) $(CWARNINGFLAGS) -o$@ $<
+
+ACPICA_SRC = ../../../source
+ACPICA_COMMON = $(ACPICA_SRC)/common
+ACPICA_TOOLS = $(ACPICA_SRC)/tools
+ACPICA_OSL = $(ACPICA_SRC)/os_specific/service_layers
+ACPICA_CORE = $(ACPICA_SRC)/components
+ACPICA_INCLUDE = $(ACPICA_SRC)/include
+ACPICA_DEBUGGER = $(ACPICA_CORE)/debugger
+ACPICA_DISASSEMBLER = $(ACPICA_CORE)/disassembler
+ACPICA_DISPATCHER = $(ACPICA_CORE)/dispatcher
+ACPICA_EVENTS = $(ACPICA_CORE)/events
+ACPICA_EXECUTER = $(ACPICA_CORE)/executer
+ACPICA_HARDWARE = $(ACPICA_CORE)/hardware
+ACPICA_NAMESPACE = $(ACPICA_CORE)/namespace
+ACPICA_PARSER = $(ACPICA_CORE)/parser
+ACPICA_RESOURCES = $(ACPICA_CORE)/resources
+ACPICA_TABLES = $(ACPICA_CORE)/tables
+ACPICA_UTILITIES = $(ACPICA_CORE)/utilities
+ACPISRC = $(ACPICA_TOOLS)/acpisrc
+INSTALLDIR = /usr/bin
+INSTALLPROG = cp --remove-destination $(PROG) $(INSTALLDIR)
+
+ACPICA_HEADERS = \
+ $(wildcard $(ACPICA_INCLUDE)/*.h) \
+ $(wildcard $(ACPICA_INCLUDE)/platform/*.h)
+
+#
+# Search path for source files and individual source files
+#
+vpath %.c \
+ $(ACPISRC) \
+ $(ACPICA_COMMON) \
+ $(ACPICA_OSL)
+
+HEADERS = \
+ $(wildcard $(ACPISRC)/*.h)
+
+OBJECTS = \
+ ascase.o \
+ asconvrt.o \
+ asfile.o \
+ asmain.o \
+ asremove.o \
+ astable.o \
+ asutils.o \
+ osunixdir.o \
+ getopt.o
+
+CFLAGS+= \
+ -D$(HOST) \
+ -D_GNU_SOURCE \
+ -DACPI_SRC_APP \
+ -I$(ACPISRC) \
+ -I$(ACPICA_INCLUDE)
+
+CWARNINGFLAGS = \
+ -ansi \
+ -Wall \
+ -Wbad-function-cast \
+ -Wdeclaration-after-statement \
+ -Werror \
+ -Wformat=2 \
+ -Wmissing-declarations \
+ -Wmissing-prototypes \
+ -Wstrict-aliasing=0 \
+ -Wstrict-prototypes \
+ -Wswitch-default \
+ -Wpointer-arith \
+ -Wundef
+
+#
+# gcc 4+ flags
+#
+CWARNINGFLAGS += \
+ -Waddress \
+ -Waggregate-return \
+ -Wchar-subscripts \
+ -Wempty-body \
+ -Wlogical-op \
+ -Wmissing-declarations \
+ -Wmissing-field-initializers \
+ -Wmissing-parameter-type \
+ -Wnested-externs \
+ -Wold-style-declaration \
+ -Wold-style-definition \
+ -Wredundant-decls \
+ -Wtype-limits
+
+#
+# Rules
+#
+$(PROG) : $(OBJECTS)
+ $(CC) $(LDFLAGS) $(OBJECTS) -o $(PROG)
+
+%.o : %.c $(HEADERS) $(ACPICA_HEADERS)
+ $(COMPILE)
+
+clean :
+ rm -f $(PROG) $(PROG).exe $(OBJECTS)
+
+install :
+ $(INSTALLPROG)
diff --git a/source/tools/acpisrc/acpisrc.h b/source/tools/acpisrc/acpisrc.h
new file mode 100644
index 0000000000000..3c0e5dc01d05f
--- /dev/null
+++ b/source/tools/acpisrc/acpisrc.h
@@ -0,0 +1,405 @@
+
+/******************************************************************************
+ *
+ * Module Name: acpisrc.h - Include file for AcpiSrc utility
+ *
+ *****************************************************************************/
+
+/*
+ * 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.
+ */
+
+
+#define LINES_IN_LEGAL_HEADER 105 /* See above */
+#define LEGAL_HEADER_SIGNATURE " * 2.1. This is your license from Intel Corp. under its intellectual property"
+#define LINES_IN_LINUX_HEADER 34
+#define LINUX_HEADER_SIGNATURE " * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS"
+#define LINES_IN_ASL_HEADER 29 /* Header as output from disassembler */
+
+#include "acpi.h"
+#include "accommon.h"
+
+#include <stdio.h>
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <ctype.h>
+#ifdef WIN32
+#include <io.h>
+#include <direct.h>
+#endif
+#include <errno.h>
+
+
+/* O_BINARY is not always defined */
+#ifndef O_BINARY
+#define O_BINARY 0x0
+#endif
+
+/* Fixups for non-Win32 compilation */
+#ifndef WIN32
+#define mkdir(x) mkdir(x, 0770)
+char * strlwr(char* str);
+#endif
+
+
+/* Constants */
+
+#define ASRC_MAX_FILE_SIZE (1024 * 100)
+
+#define FILE_TYPE_SOURCE 1
+#define FILE_TYPE_HEADER 2
+#define FILE_TYPE_DIRECTORY 3
+
+#define CVT_COUNT_TABS 0x00000001
+#define CVT_COUNT_NON_ANSI_COMMENTS 0x00000002
+#define CVT_TRIM_LINES 0x00000004
+#define CVT_CHECK_BRACES 0x00000008
+#define CVT_COUNT_LINES 0x00000010
+#define CVT_BRACES_ON_SAME_LINE 0x00000020
+#define CVT_MIXED_CASE_TO_UNDERSCORES 0x00000040
+#define CVT_LOWER_CASE_IDENTIFIERS 0x00000080
+#define CVT_REMOVE_DEBUG_MACROS 0x00000100
+#define CVT_TRIM_WHITESPACE 0x00000200 /* Should be after all line removal */
+#define CVT_REMOVE_EMPTY_BLOCKS 0x00000400 /* Should be after trimming lines */
+#define CVT_REDUCE_TYPEDEFS 0x00000800
+#define CVT_COUNT_SHORTMULTILINE_COMMENTS 0x00001000
+#define CVT_SPACES_TO_TABS4 0x40000000 /* Tab conversion should be last */
+#define CVT_SPACES_TO_TABS8 0x80000000 /* Tab conversion should be last */
+
+#define FLG_DEFAULT_FLAGS 0x00000000
+#define FLG_NO_CARRIAGE_RETURNS 0x00000001
+#define FLG_NO_FILE_OUTPUT 0x00000002
+#define FLG_LOWERCASE_DIRNAMES 0x00000004
+
+#define AS_START_IGNORE "/*!"
+#define AS_STOP_IGNORE "!*/"
+
+
+/* Globals */
+
+extern UINT32 Gbl_Files;
+extern UINT32 Gbl_MissingBraces;
+extern UINT32 Gbl_Tabs;
+extern UINT32 Gbl_NonAnsiComments;
+extern UINT32 Gbl_SourceLines;
+extern UINT32 Gbl_WhiteLines;
+extern UINT32 Gbl_CommentLines;
+extern UINT32 Gbl_LongLines;
+extern UINT32 Gbl_TotalLines;
+extern UINT32 Gbl_HeaderSize;
+extern UINT32 Gbl_HeaderLines;
+extern struct stat Gbl_StatBuf;
+extern char *Gbl_FileBuffer;
+extern UINT32 Gbl_TotalSize;
+extern UINT32 Gbl_FileSize;
+extern UINT32 Gbl_FileType;
+extern BOOLEAN Gbl_VerboseMode;
+extern BOOLEAN Gbl_QuietMode;
+extern BOOLEAN Gbl_BatchMode;
+extern BOOLEAN Gbl_MadeChanges;
+extern BOOLEAN Gbl_Overwrite;
+extern BOOLEAN Gbl_WidenDeclarations;
+extern BOOLEAN Gbl_IgnoreLoneLineFeeds;
+extern BOOLEAN Gbl_HasLoneLineFeeds;
+extern void *Gbl_StructDefs;
+
+#define PARAM_LIST(pl) pl
+#define TERSE_PRINT(a) if (!Gbl_VerboseMode) printf PARAM_LIST(a)
+#define VERBOSE_PRINT(a) if (Gbl_VerboseMode) printf PARAM_LIST(a)
+
+#define REPLACE_WHOLE_WORD 0x00
+#define REPLACE_SUBSTRINGS 0x01
+#define REPLACE_MASK 0x01
+
+#define EXTRA_INDENT_C 0x02
+
+
+/* Conversion table structs */
+
+typedef struct acpi_string_table
+{
+ char *Target;
+ char *Replacement;
+ UINT8 Type;
+
+} ACPI_STRING_TABLE;
+
+
+typedef struct acpi_typed_identifier_table
+{
+ char *Identifier;
+ UINT8 Type;
+
+} ACPI_TYPED_IDENTIFIER_TABLE;
+
+#define SRC_TYPE_SIMPLE 0
+#define SRC_TYPE_STRUCT 1
+#define SRC_TYPE_UNION 2
+
+
+typedef struct acpi_identifier_table
+{
+ char *Identifier;
+
+} ACPI_IDENTIFIER_TABLE;
+
+typedef struct acpi_conversion_table
+{
+ char *NewHeader;
+ UINT32 Flags;
+
+ ACPI_TYPED_IDENTIFIER_TABLE *LowerCaseTable;
+
+ ACPI_STRING_TABLE *SourceStringTable;
+ ACPI_IDENTIFIER_TABLE *SourceLineTable;
+ ACPI_IDENTIFIER_TABLE *SourceConditionalTable;
+ ACPI_IDENTIFIER_TABLE *SourceMacroTable;
+ ACPI_TYPED_IDENTIFIER_TABLE *SourceStructTable;
+ UINT32 SourceFunctions;
+
+ ACPI_STRING_TABLE *HeaderStringTable;
+ ACPI_IDENTIFIER_TABLE *HeaderLineTable;
+ ACPI_IDENTIFIER_TABLE *HeaderConditionalTable;
+ ACPI_IDENTIFIER_TABLE *HeaderMacroTable;
+ ACPI_TYPED_IDENTIFIER_TABLE *HeaderStructTable;
+ UINT32 HeaderFunctions;
+
+} ACPI_CONVERSION_TABLE;
+
+
+/* Conversion tables */
+
+extern ACPI_CONVERSION_TABLE LinuxConversionTable;
+extern ACPI_CONVERSION_TABLE CleanupConversionTable;
+extern ACPI_CONVERSION_TABLE StatsConversionTable;
+extern ACPI_CONVERSION_TABLE CustomConversionTable;
+extern ACPI_CONVERSION_TABLE LicenseConversionTable;
+
+
+/* Prototypes */
+
+char *
+AsSkipUntilChar (
+ char *Buffer,
+ char Target);
+
+char *
+AsSkipPastChar (
+ char *Buffer,
+ char Target);
+
+char *
+AsReplaceData (
+ char *Buffer,
+ UINT32 LengthToRemove,
+ char *BufferToAdd,
+ UINT32 LengthToAdd);
+
+int
+AsReplaceString (
+ char *Target,
+ char *Replacement,
+ UINT8 Type,
+ char *Buffer);
+
+int
+AsLowerCaseString (
+ char *Target,
+ char *Buffer);
+
+void
+AsRemoveLine (
+ char *Buffer,
+ char *Keyword);
+
+void
+AsRemoveMacro (
+ char *Buffer,
+ char *Keyword);
+
+void
+AsCheckForBraces (
+ char *Buffer,
+ char *Filename);
+
+void
+AsTrimLines (
+ char *Buffer,
+ char *Filename);
+
+void
+AsMixedCaseToUnderscores (
+ char *Buffer);
+
+void
+AsCountTabs (
+ char *Buffer,
+ char *Filename);
+
+void
+AsBracesOnSameLine (
+ char *Buffer);
+
+void
+AsLowerCaseIdentifiers (
+ char *Buffer);
+
+void
+AsReduceTypedefs (
+ char *Buffer,
+ char *Keyword);
+
+void
+AsRemoveDebugMacros (
+ char *Buffer);
+
+void
+AsRemoveEmptyBlocks (
+ char *Buffer,
+ char *Filename);
+
+void
+AsCountSourceLines (
+ char *Buffer,
+ char *Filename);
+
+void
+AsCountNonAnsiComments (
+ char *Buffer,
+ char *Filename);
+
+void
+AsTrimWhitespace (
+ char *Buffer);
+
+void
+AsTabify4 (
+ char *Buffer);
+
+void
+AsTabify8 (
+ char *Buffer);
+
+void
+AsRemoveConditionalCompile (
+ char *Buffer,
+ char *Keyword);
+
+ACPI_NATIVE_INT
+AsProcessTree (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *SourcePath,
+ char *TargetPath);
+
+int
+AsGetFile (
+ char *FileName,
+ char **FileBuffer,
+ UINT32 *FileSize);
+
+int
+AsPutFile (
+ char *Pathname,
+ char *FileBuffer,
+ UINT32 SystemFlags);
+
+void
+AsReplaceHeader (
+ char *Buffer,
+ char *NewHeader);
+
+void
+AsConvertFile (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *FileBuffer,
+ char *Filename,
+ ACPI_NATIVE_INT FileType);
+
+ACPI_NATIVE_INT
+AsProcessOneFile (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *SourcePath,
+ char *TargetPath,
+ int MaxPathLength,
+ char *Filename,
+ ACPI_NATIVE_INT FileType);
+
+ACPI_NATIVE_INT
+AsCheckForDirectory (
+ char *SourceDirPath,
+ char *TargetDirPath,
+ char *Filename,
+ char **SourcePath,
+ char **TargetPath);
+
+BOOLEAN
+AsMatchExactWord (
+ char *Word,
+ UINT32 WordLength);
+
+void
+AsPrint (
+ char *Message,
+ UINT32 Count,
+ char *Filename);
+
+void
+AsInsertPrefix (
+ char *Buffer,
+ char *Keyword,
+ UINT8 Type);
+
+char *
+AsInsertData (
+ char *Buffer,
+ char *BufferToAdd,
+ UINT32 LengthToAdd);
+
+char *
+AsRemoveData (
+ char *StartPointer,
+ char *EndPointer);
+
+void
+AsInsertCarriageReturns (
+ char *Buffer);
+
+void
+AsConvertToLineFeeds (
+ char *Buffer);
+
+
diff --git a/source/tools/acpisrc/ascase.c b/source/tools/acpisrc/ascase.c
new file mode 100644
index 0000000000000..232ebe8b18fc3
--- /dev/null
+++ b/source/tools/acpisrc/ascase.c
@@ -0,0 +1,574 @@
+
+/******************************************************************************
+ *
+ * Module Name: ascase - Source conversion - lower/upper case utilities
+ *
+ *****************************************************************************/
+
+/*
+ * 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.
+ */
+
+#include "acpisrc.h"
+
+/* Local prototypes */
+
+void
+AsUppercaseTokens (
+ char *Buffer,
+ char *PrefixString);
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsLowerCaseString
+ *
+ * DESCRIPTION: LowerCase all instances of a target string with a replacement
+ * string. Returns count of the strings replaced.
+ *
+ ******************************************************************************/
+
+int
+AsLowerCaseString (
+ char *Target,
+ char *Buffer)
+{
+ char *SubString1;
+ char *SubString2;
+ char *SubBuffer;
+ int TargetLength;
+ int LowerCaseCount = 0;
+ int i;
+
+
+ TargetLength = strlen (Target);
+
+ SubBuffer = Buffer;
+ SubString1 = Buffer;
+
+ while (SubString1)
+ {
+ /* Find the target string */
+
+ SubString1 = strstr (SubBuffer, Target);
+ if (!SubString1)
+ {
+ return LowerCaseCount;
+ }
+
+ /*
+ * Check for translation escape string -- means to ignore
+ * blocks of code while replacing
+ */
+ SubString2 = strstr (SubBuffer, AS_START_IGNORE);
+
+ if ((SubString2) &&
+ (SubString2 < SubString1))
+ {
+ /* Find end of the escape block starting at "Substring2" */
+
+ SubString2 = strstr (SubString2, AS_STOP_IGNORE);
+ if (!SubString2)
+ {
+ /* Didn't find terminator */
+
+ return LowerCaseCount;
+ }
+
+ /* Move buffer to end of escape block and continue */
+
+ SubBuffer = SubString2;
+ }
+
+ /* Do the actual replace if the target was found */
+
+ else
+ {
+ if (!AsMatchExactWord (SubString1, TargetLength))
+ {
+ SubBuffer = SubString1 + 1;
+ continue;
+ }
+
+ for (i = 0; i < TargetLength; i++)
+ {
+ SubString1[i] = (char) tolower ((int) SubString1[i]);
+ }
+
+ SubBuffer = SubString1 + TargetLength;
+
+ if ((Gbl_WidenDeclarations) && (!Gbl_StructDefs))
+ {
+ if ((SubBuffer[0] == ' ') && (SubBuffer[1] == ' '))
+ {
+ AsInsertData (SubBuffer, " ", 8);
+ }
+ }
+
+ LowerCaseCount++;
+ }
+ }
+
+ return LowerCaseCount;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsMixedCaseToUnderscores
+ *
+ * DESCRIPTION: Converts mixed case identifiers to underscored identifiers.
+ * for example,
+ *
+ * ThisUsefullyNamedIdentifier becomes:
+ *
+ * this_usefully_named_identifier
+ *
+ ******************************************************************************/
+
+void
+AsMixedCaseToUnderscores (
+ char *Buffer)
+{
+ UINT32 Length;
+ char *SubBuffer = Buffer;
+ char *TokenEnd;
+ char *TokenStart = NULL;
+ char *SubString;
+ BOOLEAN HasLowerCase = FALSE;
+
+
+ while (*SubBuffer)
+ {
+ /* Ignore whitespace */
+
+ if (*SubBuffer == ' ')
+ {
+ while (*SubBuffer == ' ')
+ {
+ SubBuffer++;
+ }
+ TokenStart = NULL;
+ HasLowerCase = FALSE;
+ continue;
+ }
+
+ /* Ignore commas */
+
+ if ((*SubBuffer == ',') ||
+ (*SubBuffer == '>') ||
+ (*SubBuffer == ')'))
+ {
+ SubBuffer++;
+ TokenStart = NULL;
+ HasLowerCase = FALSE;
+ continue;
+ }
+
+ /* Check for quoted string -- ignore */
+
+ if (*SubBuffer == '"')
+ {
+ SubBuffer++;
+ while (*SubBuffer != '"')
+ {
+ if (!*SubBuffer)
+ {
+ return;
+ }
+
+ /* Handle embedded escape sequences */
+
+ if (*SubBuffer == '\\')
+ {
+ SubBuffer++;
+ }
+ SubBuffer++;
+ }
+ SubBuffer++;
+ continue;
+ }
+
+ if (islower ((int) *SubBuffer))
+ {
+ HasLowerCase = TRUE;
+ }
+
+ /*
+ * Check for translation escape string -- means to ignore
+ * blocks of code while replacing
+ */
+ if ((SubBuffer[0] == '/') &&
+ (SubBuffer[1] == '*') &&
+ (SubBuffer[2] == '!'))
+ {
+ SubBuffer = strstr (SubBuffer, "!*/");
+ if (!SubBuffer)
+ {
+ return;
+ }
+ continue;
+ }
+
+ /* Ignore hex constants */
+
+ if (SubBuffer[0] == '0')
+ {
+ if ((SubBuffer[1] == 'x') ||
+ (SubBuffer[1] == 'X'))
+ {
+ SubBuffer += 2;
+ while (isxdigit ((int) *SubBuffer))
+ {
+ SubBuffer++;
+ }
+ continue;
+ }
+ }
+
+/* OBSOLETE CODE, all quoted strings now completely ignored. */
+#if 0
+ /* Ignore format specification fields */
+
+ if (SubBuffer[0] == '%')
+ {
+ SubBuffer++;
+
+ while ((isalnum (*SubBuffer)) || (*SubBuffer == '.'))
+ {
+ SubBuffer++;
+ }
+
+ continue;
+ }
+#endif
+
+ /* Ignore standard escape sequences (\n, \r, etc.) Not Hex or Octal escapes */
+
+ if (SubBuffer[0] == '\\')
+ {
+ SubBuffer += 2;
+ continue;
+ }
+
+ /*
+ * Ignore identifiers that already contain embedded underscores
+ * These are typically C macros or defines (all upper case)
+ * Note: there are some cases where identifiers have underscores
+ * AcpiGbl_* for example. HasLowerCase flag handles these.
+ */
+ if ((*SubBuffer == '_') && (!HasLowerCase) && (TokenStart))
+ {
+ /* Check the rest of the identifier for any lower case letters */
+
+ SubString = SubBuffer;
+ while ((isalnum ((int) *SubString)) || (*SubString == '_'))
+ {
+ if (islower ((int) *SubString))
+ {
+ HasLowerCase = TRUE;
+ }
+ SubString++;
+ }
+
+ /* If no lower case letters, we can safely ignore the entire token */
+
+ if (!HasLowerCase)
+ {
+ SubBuffer = SubString;
+ continue;
+ }
+ }
+
+ /* A capital letter may indicate the start of a token; save it */
+
+ if (isupper ((int) SubBuffer[0]))
+ {
+ TokenStart = SubBuffer;
+ }
+
+ /*
+ * Convert each pair of letters that matches the form:
+ *
+ * <LowerCase><UpperCase>
+ * to
+ * <LowerCase><Underscore><LowerCase>
+ */
+ else if ((islower ((int) SubBuffer[0]) || isdigit ((int) SubBuffer[0])) &&
+ (isupper ((int) SubBuffer[1])))
+ {
+ if (isdigit ((int) SubBuffer[0]))
+ {
+ /* Ignore <UpperCase><Digit><UpperCase> */
+ /* Ignore <Underscore><Digit><UpperCase> */
+
+ if (isupper ((int) *(SubBuffer-1)) ||
+ *(SubBuffer-1) == '_')
+ {
+ SubBuffer++;
+ continue;
+ }
+ }
+
+ /*
+ * Matched the pattern.
+ * Find the end of this identifier (token)
+ */
+ TokenEnd = SubBuffer;
+ while ((isalnum ((int) *TokenEnd)) || (*TokenEnd == '_'))
+ {
+ TokenEnd++;
+ }
+
+ /* Force the UpperCase letter (#2) to lower case */
+
+ Gbl_MadeChanges = TRUE;
+ SubBuffer[1] = (char) tolower ((int) SubBuffer[1]);
+
+ SubString = TokenEnd;
+ Length = 0;
+
+ while (*SubString != '\n')
+ {
+ /*
+ * If we have at least two trailing spaces, we can get rid of
+ * one to make up for the newly inserted underscore. This will
+ * help preserve the alignment of the text
+ */
+ if ((SubString[0] == ' ') &&
+ (SubString[1] == ' '))
+ {
+ Length = SubString - SubBuffer - 2;
+ break;
+ }
+
+ SubString++;
+ }
+
+ if (!Length)
+ {
+ Length = strlen (&SubBuffer[1]);
+ }
+
+ memmove (&SubBuffer[2], &SubBuffer[1], Length + 1);
+ SubBuffer[1] = '_';
+ SubBuffer +=2;
+
+ /* Lower case the leading character of the token */
+
+ if (TokenStart)
+ {
+ *TokenStart = (char) tolower ((int) *TokenStart);
+ TokenStart = NULL;
+ }
+ }
+
+ SubBuffer++;
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsLowerCaseIdentifiers
+ *
+ * DESCRIPTION: Converts mixed case identifiers to lower case. Leaves comments,
+ * quoted strings, and all-upper-case macros alone.
+ *
+ ******************************************************************************/
+
+void
+AsLowerCaseIdentifiers (
+ char *Buffer)
+{
+ char *SubBuffer = Buffer;
+
+
+ while (*SubBuffer)
+ {
+ /*
+ * Check for translation escape string -- means to ignore
+ * blocks of code while replacing
+ */
+ if ((SubBuffer[0] == '/') &&
+ (SubBuffer[1] == '*') &&
+ (SubBuffer[2] == '!'))
+ {
+ SubBuffer = strstr (SubBuffer, "!*/");
+ if (!SubBuffer)
+ {
+ return;
+ }
+ }
+
+ /* Ignore comments */
+
+ if ((SubBuffer[0] == '/') &&
+ (SubBuffer[1] == '*'))
+ {
+ SubBuffer = strstr (SubBuffer, "*/");
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ SubBuffer += 2;
+ }
+
+ /* Ignore quoted strings */
+
+ if ((SubBuffer[0] == '\"') && (SubBuffer[1] != '\''))
+ {
+ SubBuffer++;
+
+ /* Find the closing quote */
+
+ while (SubBuffer[0])
+ {
+ /* Ignore escaped quote characters */
+
+ if (SubBuffer[0] == '\\')
+ {
+ SubBuffer++;
+ }
+ else if (SubBuffer[0] == '\"')
+ {
+ SubBuffer++;
+ break;
+ }
+ SubBuffer++;
+ }
+ }
+
+ if (!SubBuffer[0])
+ {
+ return;
+ }
+
+ /*
+ * Only lower case if we have an upper followed by a lower
+ * This leaves the all-uppercase things (macros, etc.) intact
+ */
+ if ((isupper ((int) SubBuffer[0])) &&
+ (islower ((int) SubBuffer[1])))
+ {
+ Gbl_MadeChanges = TRUE;
+ *SubBuffer = (char) tolower ((int) *SubBuffer);
+ }
+
+ SubBuffer++;
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsUppercaseTokens
+ *
+ * DESCRIPTION: Force to uppercase all tokens that begin with the prefix string.
+ * used to convert mixed-case macros and constants to uppercase.
+ *
+ ******************************************************************************/
+
+void
+AsUppercaseTokens (
+ char *Buffer,
+ char *PrefixString)
+{
+ char *SubBuffer;
+ char *TokenEnd;
+ char *SubString;
+ int i;
+ UINT32 Length;
+
+
+ SubBuffer = Buffer;
+
+ while (SubBuffer)
+ {
+ SubBuffer = strstr (SubBuffer, PrefixString);
+ if (SubBuffer)
+ {
+ TokenEnd = SubBuffer;
+ while ((isalnum ((int) *TokenEnd)) || (*TokenEnd == '_'))
+ {
+ TokenEnd++;
+ }
+
+ for (i = 0; i < (TokenEnd - SubBuffer); i++)
+ {
+ if ((islower ((int) SubBuffer[i])) &&
+ (isupper ((int) SubBuffer[i+1])))
+ {
+
+ SubString = TokenEnd;
+ Length = 0;
+
+ while (*SubString != '\n')
+ {
+ if ((SubString[0] == ' ') &&
+ (SubString[1] == ' '))
+ {
+ Length = SubString - &SubBuffer[i] - 2;
+ break;
+ }
+
+ SubString++;
+ }
+
+ if (!Length)
+ {
+ Length = strlen (&SubBuffer[i+1]);
+ }
+
+ memmove (&SubBuffer[i+2], &SubBuffer[i+1], (Length+1));
+ SubBuffer[i+1] = '_';
+ i +=2;
+ TokenEnd++;
+ }
+ }
+
+ for (i = 0; i < (TokenEnd - SubBuffer); i++)
+ {
+ SubBuffer[i] = (char) toupper ((int) SubBuffer[i]);
+ }
+
+ SubBuffer = TokenEnd;
+ }
+ }
+}
+
+
diff --git a/source/tools/acpisrc/asconvrt.c b/source/tools/acpisrc/asconvrt.c
new file mode 100644
index 0000000000000..1669f9d20e79a
--- /dev/null
+++ b/source/tools/acpisrc/asconvrt.c
@@ -0,0 +1,1448 @@
+
+/******************************************************************************
+ *
+ * Module Name: asconvrt - Source conversion code
+ *
+ *****************************************************************************/
+
+/*
+ * 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.
+ */
+
+#include "acpisrc.h"
+
+/* Local prototypes */
+
+char *
+AsCheckAndSkipLiterals (
+ char *Buffer,
+ UINT32 *TotalLines);
+
+UINT32
+AsCountLines (
+ char *Buffer,
+ char *Filename);
+
+/* Opening signature of the Intel legal header */
+
+char *HeaderBegin = "/******************************************************************************\n *\n * 1. Copyright Notice";
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsMatchExactWord
+ *
+ * DESCRIPTION: Check previous and next characters for whitespace
+ *
+ ******************************************************************************/
+
+BOOLEAN
+AsMatchExactWord (
+ char *Word,
+ UINT32 WordLength)
+{
+ char NextChar;
+ char PrevChar;
+
+
+ NextChar = Word[WordLength];
+ PrevChar = * (Word -1);
+
+ if (isalnum ((int) NextChar) ||
+ (NextChar == '_') ||
+ isalnum ((int) PrevChar) ||
+ (PrevChar == '_'))
+ {
+ return (FALSE);
+ }
+
+ return (TRUE);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsPrint
+ *
+ * DESCRIPTION: Common formatted print
+ *
+ ******************************************************************************/
+
+void
+AsPrint (
+ char *Message,
+ UINT32 Count,
+ char *Filename)
+{
+
+ if (Gbl_QuietMode)
+ {
+ return;
+ }
+
+ printf ("-- %4u %28.28s : %s\n", Count, Message, Filename);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsCheckAndSkipLiterals
+ *
+ * DESCRIPTION: Generic routine to skip comments and quoted string literals.
+ * Keeps a line count.
+ *
+ ******************************************************************************/
+
+char *
+AsCheckAndSkipLiterals (
+ char *Buffer,
+ UINT32 *TotalLines)
+{
+ UINT32 NewLines = 0;
+ char *SubBuffer = Buffer;
+ char *LiteralEnd;
+
+
+ /* Ignore comments */
+
+ if ((SubBuffer[0] == '/') &&
+ (SubBuffer[1] == '*'))
+ {
+ LiteralEnd = strstr (SubBuffer, "*/");
+ SubBuffer += 2; /* Get past comment opening */
+
+ if (!LiteralEnd)
+ {
+ return SubBuffer;
+ }
+
+ while (SubBuffer < LiteralEnd)
+ {
+ if (*SubBuffer == '\n')
+ {
+ NewLines++;
+ }
+
+ SubBuffer++;
+ }
+
+ SubBuffer += 2; /* Get past comment close */
+ }
+
+ /* Ignore quoted strings */
+
+ else if (*SubBuffer == '\"')
+ {
+ SubBuffer++;
+ LiteralEnd = AsSkipPastChar (SubBuffer, '\"');
+ if (!LiteralEnd)
+ {
+ return SubBuffer;
+ }
+ }
+
+ if (TotalLines)
+ {
+ (*TotalLines) += NewLines;
+ }
+ return SubBuffer;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsAsCheckForBraces
+ *
+ * DESCRIPTION: Check for an open brace after each if statement
+ *
+ ******************************************************************************/
+
+void
+AsCheckForBraces (
+ char *Buffer,
+ char *Filename)
+{
+ char *SubBuffer = Buffer;
+ char *NextBrace;
+ char *NextSemicolon;
+ char *NextIf;
+ UINT32 TotalLines = 1;
+
+
+ while (*SubBuffer)
+ {
+
+ SubBuffer = AsCheckAndSkipLiterals (SubBuffer, &TotalLines);
+
+ if (*SubBuffer == '\n')
+ {
+ TotalLines++;
+ }
+ else if (!(strncmp (" if", SubBuffer, 3)))
+ {
+ SubBuffer += 2;
+ NextBrace = strstr (SubBuffer, "{");
+ NextSemicolon = strstr (SubBuffer, ";");
+ NextIf = strstr (SubBuffer, " if");
+
+ if ((!NextBrace) ||
+ (NextSemicolon && (NextBrace > NextSemicolon)) ||
+ (NextIf && (NextBrace > NextIf)))
+ {
+ Gbl_MissingBraces++;
+
+ if (!Gbl_QuietMode)
+ {
+ printf ("Missing braces for <if>, line %u: %s\n", TotalLines, Filename);
+ }
+ }
+ }
+ else if (!(strncmp (" else if", SubBuffer, 8)))
+ {
+ SubBuffer += 7;
+ NextBrace = strstr (SubBuffer, "{");
+ NextSemicolon = strstr (SubBuffer, ";");
+ NextIf = strstr (SubBuffer, " if");
+
+ if ((!NextBrace) ||
+ (NextSemicolon && (NextBrace > NextSemicolon)) ||
+ (NextIf && (NextBrace > NextIf)))
+ {
+ Gbl_MissingBraces++;
+
+ if (!Gbl_QuietMode)
+ {
+ printf ("Missing braces for <if>, line %u: %s\n", TotalLines, Filename);
+ }
+ }
+ }
+ else if (!(strncmp (" else", SubBuffer, 5)))
+ {
+ SubBuffer += 4;
+ NextBrace = strstr (SubBuffer, "{");
+ NextSemicolon = strstr (SubBuffer, ";");
+ NextIf = strstr (SubBuffer, " if");
+
+ if ((!NextBrace) ||
+ (NextSemicolon && (NextBrace > NextSemicolon)) ||
+ (NextIf && (NextBrace > NextIf)))
+ {
+ Gbl_MissingBraces++;
+
+ if (!Gbl_QuietMode)
+ {
+ printf ("Missing braces for <else>, line %u: %s\n", TotalLines, Filename);
+ }
+ }
+ }
+
+ SubBuffer++;
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsTrimLines
+ *
+ * DESCRIPTION: Remove extra blanks from the end of source lines. Does not
+ * check for tabs.
+ *
+ ******************************************************************************/
+
+void
+AsTrimLines (
+ char *Buffer,
+ char *Filename)
+{
+ char *SubBuffer = Buffer;
+ char *StartWhiteSpace = NULL;
+ UINT32 SpaceCount = 0;
+
+
+ while (*SubBuffer)
+ {
+ while (*SubBuffer != '\n')
+ {
+ if (!*SubBuffer)
+ {
+ goto Exit;
+ }
+
+ if (*SubBuffer == ' ')
+ {
+ if (!StartWhiteSpace)
+ {
+ StartWhiteSpace = SubBuffer;
+ }
+ }
+ else
+ {
+ StartWhiteSpace = NULL;
+ }
+
+ SubBuffer++;
+ }
+
+ if (StartWhiteSpace)
+ {
+ SpaceCount += (SubBuffer - StartWhiteSpace);
+
+ /* Remove the spaces */
+
+ SubBuffer = AsRemoveData (StartWhiteSpace, SubBuffer);
+ StartWhiteSpace = NULL;
+ }
+
+ SubBuffer++;
+ }
+
+
+Exit:
+ if (SpaceCount)
+ {
+ Gbl_MadeChanges = TRUE;
+ AsPrint ("Extraneous spaces removed", SpaceCount, Filename);
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsTrimWhitespace
+ *
+ * DESCRIPTION: Remove "excess" blank lines - any more than 2 blank lines.
+ * this can happen during the translation when lines are removed.
+ *
+ ******************************************************************************/
+
+void
+AsTrimWhitespace (
+ char *Buffer)
+{
+ int ReplaceCount = 1;
+
+
+ while (ReplaceCount)
+ {
+ ReplaceCount = AsReplaceString ("\n\n\n\n", "\n\n\n", REPLACE_SUBSTRINGS, Buffer);
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsReplaceHeader
+ *
+ * DESCRIPTION: Replace the default Intel legal header with a new header
+ *
+ ******************************************************************************/
+
+void
+AsReplaceHeader (
+ char *Buffer,
+ char *NewHeader)
+{
+ char *SubBuffer;
+ char *TokenEnd;
+
+
+ /* Find the original header */
+
+ SubBuffer = strstr (Buffer, HeaderBegin);
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ /* Find the end of the original header */
+
+ TokenEnd = strstr (SubBuffer, "*/");
+ TokenEnd = AsSkipPastChar (TokenEnd, '\n');
+
+ /* Delete old header, insert new one */
+
+ AsReplaceData (SubBuffer, TokenEnd - SubBuffer, NewHeader, strlen (NewHeader));
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsReplaceString
+ *
+ * DESCRIPTION: Replace all instances of a target string with a replacement
+ * string. Returns count of the strings replaced.
+ *
+ ******************************************************************************/
+
+int
+AsReplaceString (
+ char *Target,
+ char *Replacement,
+ UINT8 Type,
+ char *Buffer)
+{
+ char *SubString1;
+ char *SubString2;
+ char *SubBuffer;
+ int TargetLength;
+ int ReplacementLength;
+ int ReplaceCount = 0;
+
+
+ TargetLength = strlen (Target);
+ ReplacementLength = strlen (Replacement);
+
+ SubBuffer = Buffer;
+ SubString1 = Buffer;
+
+ while (SubString1)
+ {
+ /* Find the target string */
+
+ SubString1 = strstr (SubBuffer, Target);
+ if (!SubString1)
+ {
+ return ReplaceCount;
+ }
+
+ /*
+ * Check for translation escape string -- means to ignore
+ * blocks of code while replacing
+ */
+ SubString2 = strstr (SubBuffer, AS_START_IGNORE);
+
+ if ((SubString2) &&
+ (SubString2 < SubString1))
+ {
+ /* Find end of the escape block starting at "Substring2" */
+
+ SubString2 = strstr (SubString2, AS_STOP_IGNORE);
+ if (!SubString2)
+ {
+ /* Didn't find terminator */
+
+ return ReplaceCount;
+ }
+
+ /* Move buffer to end of escape block and continue */
+
+ SubBuffer = SubString2;
+ }
+
+ /* Do the actual replace if the target was found */
+
+ else
+ {
+ if ((Type & REPLACE_MASK) == REPLACE_WHOLE_WORD)
+ {
+ if (!AsMatchExactWord (SubString1, TargetLength))
+ {
+ SubBuffer = SubString1 + 1;
+ continue;
+ }
+ }
+
+ SubBuffer = AsReplaceData (SubString1, TargetLength, Replacement, ReplacementLength);
+
+ if ((Type & EXTRA_INDENT_C) &&
+ (!Gbl_StructDefs))
+ {
+ SubBuffer = AsInsertData (SubBuffer, " ", 8);
+ }
+
+ ReplaceCount++;
+ }
+ }
+
+ return ReplaceCount;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsConvertToLineFeeds
+ *
+ * DESCRIPTION:
+ *
+ ******************************************************************************/
+
+void
+AsConvertToLineFeeds (
+ char *Buffer)
+{
+ char *SubString;
+ char *SubBuffer;
+
+
+ SubBuffer = Buffer;
+ SubString = Buffer;
+
+ while (SubString)
+ {
+ /* Find the target string */
+
+ SubString = strstr (SubBuffer, "\r\n");
+ if (!SubString)
+ {
+ return;
+ }
+
+ SubBuffer = AsReplaceData (SubString, 1, NULL, 0);
+ }
+ return;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsInsertCarriageReturns
+ *
+ * DESCRIPTION:
+ *
+ ******************************************************************************/
+
+void
+AsInsertCarriageReturns (
+ char *Buffer)
+{
+ char *SubString;
+ char *SubBuffer;
+
+
+ SubBuffer = Buffer;
+ SubString = Buffer;
+
+ while (SubString)
+ {
+ /* Find the target string */
+
+ SubString = strstr (SubBuffer, "\n");
+ if (!SubString)
+ {
+ return;
+ }
+
+ SubBuffer = AsInsertData (SubString, "\r", 1);
+ SubBuffer += 1;
+ }
+ return;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsBracesOnSameLine
+ *
+ * DESCRIPTION: Move opening braces up to the same line as an if, for, else,
+ * or while statement (leave function opening brace on separate
+ * line).
+ *
+ ******************************************************************************/
+
+void
+AsBracesOnSameLine (
+ char *Buffer)
+{
+ char *SubBuffer = Buffer;
+ char *Beginning;
+ char *StartOfThisLine;
+ char *Next;
+ BOOLEAN BlockBegin = TRUE;
+
+
+ while (*SubBuffer)
+ {
+ /* Ignore comments */
+
+ if ((SubBuffer[0] == '/') &&
+ (SubBuffer[1] == '*'))
+ {
+ SubBuffer = strstr (SubBuffer, "*/");
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ SubBuffer += 2;
+ continue;
+ }
+
+ /* Ignore quoted strings */
+
+ if (*SubBuffer == '\"')
+ {
+ SubBuffer++;
+ SubBuffer = AsSkipPastChar (SubBuffer, '\"');
+ if (!SubBuffer)
+ {
+ return;
+ }
+ }
+
+ if (!strncmp ("\n}", SubBuffer, 2))
+ {
+ /*
+ * A newline followed by a closing brace closes a function
+ * or struct or initializer block
+ */
+ BlockBegin = TRUE;
+ }
+
+ /*
+ * Move every standalone brace up to the previous line
+ * Check for digit will ignore initializer lists surrounded by braces.
+ * This will work until we we need more complex detection.
+ */
+ if ((*SubBuffer == '{') && !isdigit ((int) SubBuffer[1]))
+ {
+ if (BlockBegin)
+ {
+ BlockBegin = FALSE;
+ }
+ else
+ {
+ /*
+ * Backup to previous non-whitespace
+ */
+ Beginning = SubBuffer - 1;
+ while ((*Beginning == ' ') ||
+ (*Beginning == '\n'))
+ {
+ Beginning--;
+ }
+
+ StartOfThisLine = Beginning;
+ while (*StartOfThisLine != '\n')
+ {
+ StartOfThisLine--;
+ }
+
+ /*
+ * Move the brace up to the previous line, UNLESS:
+ *
+ * 1) There is a conditional compile on the line (starts with '#')
+ * 2) Previous line ends with an '=' (Start of initializer block)
+ * 3) Previous line ends with a comma (part of an init list)
+ * 4) Previous line ends with a backslash (part of a macro)
+ */
+ if ((StartOfThisLine[1] != '#') &&
+ (*Beginning != '\\') &&
+ (*Beginning != '/') &&
+ (*Beginning != '{') &&
+ (*Beginning != '=') &&
+ (*Beginning != ','))
+ {
+ Beginning++;
+ SubBuffer++;
+
+ Gbl_MadeChanges = TRUE;
+
+#ifdef ADD_EXTRA_WHITESPACE
+ AsReplaceData (Beginning, SubBuffer - Beginning, " {\n", 3);
+#else
+ /* Find non-whitespace start of next line */
+
+ Next = SubBuffer + 1;
+ while ((*Next == ' ') ||
+ (*Next == '\t'))
+ {
+ Next++;
+ }
+
+ /* Find non-whitespace start of this line */
+
+ StartOfThisLine++;
+ while ((*StartOfThisLine == ' ') ||
+ (*StartOfThisLine == '\t'))
+ {
+ StartOfThisLine++;
+ }
+
+ /*
+ * Must be a single-line comment to need more whitespace
+ * Even then, we don't need more if the previous statement
+ * is an "else".
+ */
+ if ((Next[0] == '/') &&
+ (Next[1] == '*') &&
+ (Next[2] != '\n') &&
+
+ (!strncmp (StartOfThisLine, "else if", 7) ||
+ !strncmp (StartOfThisLine, "else while", 10) ||
+ strncmp (StartOfThisLine, "else", 4)))
+ {
+ AsReplaceData (Beginning, SubBuffer - Beginning, " {\n", 3);
+ }
+ else
+ {
+ AsReplaceData (Beginning, SubBuffer - Beginning, " {", 2);
+ }
+#endif
+ }
+ }
+ }
+
+ SubBuffer++;
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsTabify4
+ *
+ * DESCRIPTION: Convert the text to tabbed text. Alignment of text is
+ * preserved.
+ *
+ ******************************************************************************/
+
+void
+AsTabify4 (
+ char *Buffer)
+{
+ char *SubBuffer = Buffer;
+ char *NewSubBuffer;
+ UINT32 SpaceCount = 0;
+ UINT32 Column = 0;
+
+
+ while (*SubBuffer)
+ {
+ if (*SubBuffer == '\n')
+ {
+ Column = 0;
+ }
+ else
+ {
+ Column++;
+ }
+
+ /* Ignore comments */
+
+ if ((SubBuffer[0] == '/') &&
+ (SubBuffer[1] == '*'))
+ {
+ SubBuffer = strstr (SubBuffer, "*/");
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ SubBuffer += 2;
+ continue;
+ }
+
+ /* Ignore quoted strings */
+
+ if (*SubBuffer == '\"')
+ {
+ SubBuffer++;
+ SubBuffer = AsSkipPastChar (SubBuffer, '\"');
+ if (!SubBuffer)
+ {
+ return;
+ }
+ SpaceCount = 0;
+ }
+
+ if (*SubBuffer == ' ')
+ {
+ SpaceCount++;
+
+ if (SpaceCount >= 4)
+ {
+ SpaceCount = 0;
+
+ NewSubBuffer = (SubBuffer + 1) - 4;
+ *NewSubBuffer = '\t';
+ NewSubBuffer++;
+
+ /* Remove the spaces */
+
+ SubBuffer = AsRemoveData (NewSubBuffer, SubBuffer + 1);
+ }
+
+ if ((Column % 4) == 0)
+ {
+ SpaceCount = 0;
+ }
+ }
+ else
+ {
+ SpaceCount = 0;
+ }
+
+ SubBuffer++;
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsTabify8
+ *
+ * DESCRIPTION: Convert the text to tabbed text. Alignment of text is
+ * preserved.
+ *
+ ******************************************************************************/
+
+void
+AsTabify8 (
+ char *Buffer)
+{
+ char *SubBuffer = Buffer;
+ char *NewSubBuffer;
+ char *CommentEnd = NULL;
+ UINT32 SpaceCount = 0;
+ UINT32 Column = 0;
+ UINT32 TabCount = 0;
+ UINT32 LastLineTabCount = 0;
+ UINT32 LastLineColumnStart = 0;
+ UINT32 ThisColumnStart = 0;
+ UINT32 ThisTabCount = 0;
+ char *FirstNonBlank = NULL;
+
+
+ while (*SubBuffer)
+ {
+ if (*SubBuffer == '\n')
+ {
+ /* This is a standalone blank line */
+
+ FirstNonBlank = NULL;
+ Column = 0;
+ SpaceCount = 0;
+ TabCount = 0;
+ SubBuffer++;
+ continue;
+ }
+
+ if (!FirstNonBlank)
+ {
+ /* Find the first non-blank character on this line */
+
+ FirstNonBlank = SubBuffer;
+ while (*FirstNonBlank == ' ')
+ {
+ FirstNonBlank++;
+ }
+
+ /*
+ * This mechanism limits the difference in tab counts from
+ * line to line. It helps avoid the situation where a second
+ * continuation line (which was indented correctly for tabs=4) would
+ * get indented off the screen if we just blindly converted to tabs.
+ */
+ ThisColumnStart = FirstNonBlank - SubBuffer;
+
+ if (LastLineTabCount == 0)
+ {
+ ThisTabCount = 0;
+ }
+ else if (ThisColumnStart == LastLineColumnStart)
+ {
+ ThisTabCount = LastLineTabCount -1;
+ }
+ else
+ {
+ ThisTabCount = LastLineTabCount + 1;
+ }
+ }
+
+ Column++;
+
+ /* Check if we are in a comment */
+
+ if ((SubBuffer[0] == '*') &&
+ (SubBuffer[1] == '/'))
+ {
+ SpaceCount = 0;
+ SubBuffer += 2;
+
+ if (*SubBuffer == '\n')
+ {
+ if (TabCount > 0)
+ {
+ LastLineTabCount = TabCount;
+ TabCount = 0;
+ }
+ FirstNonBlank = NULL;
+ LastLineColumnStart = ThisColumnStart;
+ SubBuffer++;
+ }
+
+ continue;
+ }
+
+ /* Check for comment open */
+
+ if ((SubBuffer[0] == '/') &&
+ (SubBuffer[1] == '*'))
+ {
+ /* Find the end of the comment, it must exist */
+
+ CommentEnd = strstr (SubBuffer, "*/");
+ if (!CommentEnd)
+ {
+ return;
+ }
+
+ /* Toss the rest of this line or single-line comment */
+
+ while ((SubBuffer < CommentEnd) &&
+ (*SubBuffer != '\n'))
+ {
+ SubBuffer++;
+ }
+
+ if (*SubBuffer == '\n')
+ {
+ if (TabCount > 0)
+ {
+ LastLineTabCount = TabCount;
+ TabCount = 0;
+ }
+ FirstNonBlank = NULL;
+ LastLineColumnStart = ThisColumnStart;
+ }
+
+ SpaceCount = 0;
+ continue;
+ }
+
+ /* Ignore quoted strings */
+
+ if ((!CommentEnd) && (*SubBuffer == '\"'))
+ {
+ SubBuffer++;
+ SubBuffer = AsSkipPastChar (SubBuffer, '\"');
+ if (!SubBuffer)
+ {
+ return;
+ }
+ SpaceCount = 0;
+ }
+
+ if (*SubBuffer != ' ')
+ {
+ /* Not a space, skip to end of line */
+
+ SubBuffer = AsSkipUntilChar (SubBuffer, '\n');
+ if (!SubBuffer)
+ {
+ return;
+ }
+ if (TabCount > 0)
+ {
+ LastLineTabCount = TabCount;
+ TabCount = 0;
+ }
+
+ FirstNonBlank = NULL;
+ LastLineColumnStart = ThisColumnStart;
+ Column = 0;
+ SpaceCount = 0;
+ }
+ else
+ {
+ /* Another space */
+
+ SpaceCount++;
+
+ if (SpaceCount >= 4)
+ {
+ /* Replace this group of spaces with a tab character */
+
+ SpaceCount = 0;
+
+ NewSubBuffer = SubBuffer - 3;
+
+ if (TabCount <= ThisTabCount ? (ThisTabCount +1) : 0)
+ {
+ *NewSubBuffer = '\t';
+ NewSubBuffer++;
+ SubBuffer++;
+ TabCount++;
+ }
+
+ /* Remove the spaces */
+
+ SubBuffer = AsRemoveData (NewSubBuffer, SubBuffer);
+ continue;
+ }
+ }
+
+ SubBuffer++;
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsCountLines
+ *
+ * DESCRIPTION: Count the number of lines in the input buffer. Also count
+ * the number of long lines (lines longer than 80 chars).
+ *
+ ******************************************************************************/
+
+UINT32
+AsCountLines (
+ char *Buffer,
+ char *Filename)
+{
+ char *SubBuffer = Buffer;
+ char *EndOfLine;
+ UINT32 LineCount = 0;
+ UINT32 LongLineCount = 0;
+
+
+ while (*SubBuffer)
+ {
+ EndOfLine = AsSkipUntilChar (SubBuffer, '\n');
+ if (!EndOfLine)
+ {
+ Gbl_TotalLines += LineCount;
+ return LineCount;
+ }
+
+ if ((EndOfLine - SubBuffer) > 80)
+ {
+ LongLineCount++;
+ VERBOSE_PRINT (("long: %.80s\n", SubBuffer));
+ }
+
+ LineCount++;
+ SubBuffer = EndOfLine + 1;
+ }
+
+ if (LongLineCount)
+ {
+ VERBOSE_PRINT (("%u Lines longer than 80 found in %s\n", LongLineCount, Filename));
+ Gbl_LongLines += LongLineCount;
+ }
+
+ Gbl_TotalLines += LineCount;
+ return LineCount;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsCountTabs
+ *
+ * DESCRIPTION: Simply count the number of tabs in the input file buffer
+ *
+ ******************************************************************************/
+
+void
+AsCountTabs (
+ char *Buffer,
+ char *Filename)
+{
+ UINT32 i;
+ UINT32 TabCount = 0;
+
+
+ for (i = 0; Buffer[i]; i++)
+ {
+ if (Buffer[i] == '\t')
+ {
+ TabCount++;
+ }
+ }
+
+ if (TabCount)
+ {
+ AsPrint ("Tabs found", TabCount, Filename);
+ Gbl_Tabs += TabCount;
+ }
+
+ AsCountLines (Buffer, Filename);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsCountNonAnsiComments
+ *
+ * DESCRIPTION: Count the number of "//" comments. This type of comment is
+ * non-ANSI C.
+ *
+ ******************************************************************************/
+
+void
+AsCountNonAnsiComments (
+ char *Buffer,
+ char *Filename)
+{
+ char *SubBuffer = Buffer;
+ UINT32 CommentCount = 0;
+
+
+ while (SubBuffer)
+ {
+ SubBuffer = strstr (SubBuffer, "//");
+ if (SubBuffer)
+ {
+ CommentCount++;
+ SubBuffer += 2;
+ }
+ }
+
+ if (CommentCount)
+ {
+ AsPrint ("Non-ANSI Comments found", CommentCount, Filename);
+ Gbl_NonAnsiComments += CommentCount;
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsCountSourceLines
+ *
+ * DESCRIPTION: Count the number of C source lines. Defined by 1) not a
+ * comment, and 2) not a blank line.
+ *
+ ******************************************************************************/
+
+void
+AsCountSourceLines (
+ char *Buffer,
+ char *Filename)
+{
+ char *SubBuffer = Buffer;
+ UINT32 LineCount = 0;
+ UINT32 WhiteCount = 0;
+ UINT32 CommentCount = 0;
+
+
+ while (*SubBuffer)
+ {
+ /* Detect comments (// comments are not used, non-ansii) */
+
+ if ((SubBuffer[0] == '/') &&
+ (SubBuffer[1] == '*'))
+ {
+ SubBuffer += 2;
+
+ /* First line of multi-line comment is often just whitespace */
+
+ if (SubBuffer[0] == '\n')
+ {
+ WhiteCount++;
+ SubBuffer++;
+ }
+ else
+ {
+ CommentCount++;
+ }
+
+ /* Find end of comment */
+
+ while (SubBuffer[0] && SubBuffer[1] &&
+ !(((SubBuffer[0] == '*') &&
+ (SubBuffer[1] == '/'))))
+ {
+ if (SubBuffer[0] == '\n')
+ {
+ CommentCount++;
+ }
+
+ SubBuffer++;
+ }
+ }
+
+ /* A linefeed followed by a non-linefeed is a valid source line */
+
+ else if ((SubBuffer[0] == '\n') &&
+ (SubBuffer[1] != '\n'))
+ {
+ LineCount++;
+ }
+
+ /* Two back-to-back linefeeds indicate a whitespace line */
+
+ else if ((SubBuffer[0] == '\n') &&
+ (SubBuffer[1] == '\n'))
+ {
+ WhiteCount++;
+ }
+
+ SubBuffer++;
+ }
+
+ /* Adjust comment count for legal header */
+
+ if (Gbl_HeaderSize < CommentCount)
+ {
+ CommentCount -= Gbl_HeaderSize;
+ Gbl_HeaderLines += Gbl_HeaderSize;
+ }
+
+ Gbl_SourceLines += LineCount;
+ Gbl_WhiteLines += WhiteCount;
+ Gbl_CommentLines += CommentCount;
+
+ VERBOSE_PRINT (("%u Comment %u White %u Code %u Lines in %s\n",
+ CommentCount, WhiteCount, LineCount, LineCount+WhiteCount+CommentCount, Filename));
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsInsertPrefix
+ *
+ * DESCRIPTION: Insert struct or union prefixes
+ *
+ ******************************************************************************/
+
+void
+AsInsertPrefix (
+ char *Buffer,
+ char *Keyword,
+ UINT8 Type)
+{
+ char *SubString;
+ char *SubBuffer;
+ char *EndKeyword;
+ int InsertLength;
+ char *InsertString;
+ int TrailingSpaces;
+ char LowerKeyword[128];
+ int KeywordLength;
+
+
+ switch (Type)
+ {
+ case SRC_TYPE_STRUCT:
+ InsertString = "struct ";
+ break;
+
+ case SRC_TYPE_UNION:
+ InsertString = "union ";
+ break;
+
+ default:
+ return;
+ }
+
+ strcpy (LowerKeyword, Keyword);
+ strlwr (LowerKeyword);
+
+ SubBuffer = Buffer;
+ SubString = Buffer;
+ InsertLength = strlen (InsertString);
+ KeywordLength = strlen (Keyword);
+
+
+ while (SubString)
+ {
+ /* Find an instance of the keyword */
+
+ SubString = strstr (SubBuffer, LowerKeyword);
+ if (!SubString)
+ {
+ return;
+ }
+
+ SubBuffer = SubString;
+
+ /* Must be standalone word, not a substring */
+
+ if (AsMatchExactWord (SubString, KeywordLength))
+ {
+ /* Make sure the keyword isn't already prefixed with the insert */
+
+ if (!strncmp (SubString - InsertLength, InsertString, InsertLength))
+ {
+ /* Add spaces if not already at the end-of-line */
+
+ if (*(SubBuffer + KeywordLength) != '\n')
+ {
+ /* Already present, add spaces after to align structure members */
+
+#if 0
+/* ONLY FOR C FILES */
+ AsInsertData (SubBuffer + KeywordLength, " ", 8);
+#endif
+ }
+ goto Next;
+ }
+
+ /* Make sure the keyword isn't at the end of a struct/union */
+ /* Note: This code depends on a single space after the brace */
+
+ if (*(SubString - 2) == '}')
+ {
+ goto Next;
+ }
+
+ /* Prefix the keyword with the insert string */
+
+ Gbl_MadeChanges = TRUE;
+
+ /* Is there room for insertion */
+
+ EndKeyword = SubString + strlen (LowerKeyword);
+
+ TrailingSpaces = 0;
+ while (EndKeyword[TrailingSpaces] == ' ')
+ {
+ TrailingSpaces++;
+ }
+
+ /*
+ * Use "if (TrailingSpaces > 1)" if we want to ignore casts
+ */
+ SubBuffer = SubString + InsertLength;
+
+ if (TrailingSpaces > InsertLength)
+ {
+ /* Insert the keyword */
+
+ memmove (SubBuffer, SubString, KeywordLength);
+
+ /* Insert the keyword */
+
+ memmove (SubString, InsertString, InsertLength);
+ }
+ else
+ {
+ AsInsertData (SubString, InsertString, InsertLength);
+ }
+ }
+
+Next:
+ SubBuffer += KeywordLength;
+ }
+}
+
+#ifdef ACPI_FUTURE_IMPLEMENTATION
+/******************************************************************************
+ *
+ * FUNCTION: AsTrimComments
+ *
+ * DESCRIPTION: Finds 3-line comments with only a single line of text
+ *
+ ******************************************************************************/
+
+void
+AsTrimComments (
+ char *Buffer,
+ char *Filename)
+{
+ char *SubBuffer = Buffer;
+ char *Ptr1;
+ char *Ptr2;
+ UINT32 LineCount;
+ UINT32 ShortCommentCount = 0;
+
+
+ while (1)
+ {
+ /* Find comment open, within procedure level */
+
+ SubBuffer = strstr (SubBuffer, " /*");
+ if (!SubBuffer)
+ {
+ goto Exit;
+ }
+
+ /* Find comment terminator */
+
+ Ptr1 = strstr (SubBuffer, "*/");
+ if (!Ptr1)
+ {
+ goto Exit;
+ }
+
+ /* Find next EOL (from original buffer) */
+
+ Ptr2 = strstr (SubBuffer, "\n");
+ if (!Ptr2)
+ {
+ goto Exit;
+ }
+
+ /* Ignore one-line comments */
+
+ if (Ptr1 < Ptr2)
+ {
+ /* Normal comment, ignore and continue; */
+
+ SubBuffer = Ptr2;
+ continue;
+ }
+
+ /* Examine multi-line comment */
+
+ LineCount = 1;
+ while (Ptr1 > Ptr2)
+ {
+ /* Find next EOL */
+
+ Ptr2++;
+ Ptr2 = strstr (Ptr2, "\n");
+ if (!Ptr2)
+ {
+ goto Exit;
+ }
+
+ LineCount++;
+ }
+
+ SubBuffer = Ptr1;
+
+ if (LineCount <= 3)
+ {
+ ShortCommentCount++;
+ }
+ }
+
+
+Exit:
+
+ if (ShortCommentCount)
+ {
+ AsPrint ("Short Comments found", ShortCommentCount, Filename);
+ }
+}
+#endif
+
+
diff --git a/source/tools/acpisrc/asfile.c b/source/tools/acpisrc/asfile.c
new file mode 100644
index 0000000000000..ce26adc3d8e4a
--- /dev/null
+++ b/source/tools/acpisrc/asfile.c
@@ -0,0 +1,815 @@
+
+/******************************************************************************
+ *
+ * Module Name: asfile - Main module for the acpi source processor utility
+ *
+ *****************************************************************************/
+
+/*
+ * 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.
+ */
+
+#include "acpisrc.h"
+
+/* Local prototypes */
+
+void
+AsDoWildcard (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *SourcePath,
+ char *TargetPath,
+ int MaxPathLength,
+ int FileType,
+ char *WildcardSpec);
+
+BOOLEAN
+AsDetectLoneLineFeeds (
+ char *Filename,
+ char *Buffer);
+
+static ACPI_INLINE int
+AsMaxInt (int a, int b)
+{
+ return (a > b ? a : b);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsDoWildcard
+ *
+ * DESCRIPTION: Process files via wildcards
+ *
+ ******************************************************************************/
+
+void
+AsDoWildcard (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *SourcePath,
+ char *TargetPath,
+ int MaxPathLength,
+ int FileType,
+ char *WildcardSpec)
+{
+ void *DirInfo;
+ char *Filename;
+ char *SourceDirPath;
+ char *TargetDirPath;
+ char RequestedFileType;
+
+
+ if (FileType == FILE_TYPE_DIRECTORY)
+ {
+ RequestedFileType = REQUEST_DIR_ONLY;
+ }
+ else
+ {
+ RequestedFileType = REQUEST_FILE_ONLY;
+ }
+
+ VERBOSE_PRINT (("Checking for %s source files in directory \"%s\"\n",
+ WildcardSpec, SourcePath));
+
+ /* Open the directory for wildcard search */
+
+ DirInfo = AcpiOsOpenDirectory (SourcePath, WildcardSpec, RequestedFileType);
+ if (DirInfo)
+ {
+ /*
+ * Get all of the files that match both the
+ * wildcard and the requested file type
+ */
+ while ((Filename = AcpiOsGetNextFilename (DirInfo)))
+ {
+ /* Looking for directory files, must check file type */
+
+ switch (RequestedFileType)
+ {
+ case REQUEST_DIR_ONLY:
+
+ /* If we actually have a dir, process the subtree */
+
+ if (!AsCheckForDirectory (SourcePath, TargetPath, Filename,
+ &SourceDirPath, &TargetDirPath))
+ {
+ VERBOSE_PRINT (("Subdirectory: %s\n", Filename));
+
+ AsProcessTree (ConversionTable, SourceDirPath, TargetDirPath);
+ free (SourceDirPath);
+ free (TargetDirPath);
+ }
+ break;
+
+ case REQUEST_FILE_ONLY:
+
+ /* Otherwise, this is a file, not a directory */
+
+ VERBOSE_PRINT (("File: %s\n", Filename));
+
+ AsProcessOneFile (ConversionTable, SourcePath, TargetPath,
+ MaxPathLength, Filename, FileType);
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ /* Cleanup */
+
+ AcpiOsCloseDirectory (DirInfo);
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsProcessTree
+ *
+ * DESCRIPTION: Process the directory tree. Files with the extension ".C" and
+ * ".H" are processed as the tree is traversed.
+ *
+ ******************************************************************************/
+
+ACPI_NATIVE_INT
+AsProcessTree (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *SourcePath,
+ char *TargetPath)
+{
+ int MaxPathLength;
+
+
+ MaxPathLength = AsMaxInt (strlen (SourcePath), strlen (TargetPath));
+
+ if (!(ConversionTable->Flags & FLG_NO_FILE_OUTPUT))
+ {
+ if (ConversionTable->Flags & FLG_LOWERCASE_DIRNAMES)
+ {
+ strlwr (TargetPath);
+ }
+
+ VERBOSE_PRINT (("Creating Directory \"%s\"\n", TargetPath));
+ if (mkdir (TargetPath))
+ {
+ if (errno != EEXIST)
+ {
+ printf ("Could not create target directory\n");
+ return -1;
+ }
+ }
+ }
+
+ /* Do the C source files */
+
+ AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength,
+ FILE_TYPE_SOURCE, "*.c");
+
+ /* Do the C header files */
+
+ AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength,
+ FILE_TYPE_HEADER, "*.h");
+
+ /* Do the Lex file(s) */
+
+ AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength,
+ FILE_TYPE_SOURCE, "*.l");
+
+ /* Do the yacc file(s) */
+
+ AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength,
+ FILE_TYPE_SOURCE, "*.y");
+
+ /* Do any ASL files */
+
+ AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength,
+ FILE_TYPE_HEADER, "*.asl");
+
+ /* Do any subdirectories */
+
+ AsDoWildcard (ConversionTable, SourcePath, TargetPath, MaxPathLength,
+ FILE_TYPE_DIRECTORY, "*");
+
+ return 0;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsDetectLoneLineFeeds
+ *
+ * DESCRIPTION: Find LF without CR.
+ *
+ ******************************************************************************/
+
+BOOLEAN
+AsDetectLoneLineFeeds (
+ char *Filename,
+ char *Buffer)
+{
+ UINT32 i = 1;
+ UINT32 LfCount = 0;
+ UINT32 LineCount = 0;
+
+
+ if (!Buffer[0])
+ {
+ return FALSE;
+ }
+
+ while (Buffer[i])
+ {
+ if (Buffer[i] == 0x0A)
+ {
+ if (Buffer[i-1] != 0x0D)
+ {
+ LfCount++;
+ }
+ LineCount++;
+ }
+ i++;
+ }
+
+ if (LfCount)
+ {
+ if (LineCount == LfCount)
+ {
+ if (!Gbl_IgnoreLoneLineFeeds)
+ {
+ printf ("%s: ****File has UNIX format**** (LF only, not CR/LF) %u lines\n",
+ Filename, LfCount);
+ }
+ }
+ else
+ {
+ printf ("%s: %u lone linefeeds in file\n", Filename, LfCount);
+ }
+ return TRUE;
+ }
+
+ return (FALSE);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsConvertFile
+ *
+ * DESCRIPTION: Perform the requested transforms on the file buffer (as
+ * determined by the ConversionTable and the FileType).
+ *
+ ******************************************************************************/
+
+void
+AsConvertFile (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *FileBuffer,
+ char *Filename,
+ ACPI_NATIVE_INT FileType)
+{
+ UINT32 i;
+ UINT32 Functions;
+ ACPI_STRING_TABLE *StringTable;
+ ACPI_IDENTIFIER_TABLE *ConditionalTable;
+ ACPI_IDENTIFIER_TABLE *LineTable;
+ ACPI_IDENTIFIER_TABLE *MacroTable;
+ ACPI_TYPED_IDENTIFIER_TABLE *StructTable;
+
+
+ switch (FileType)
+ {
+ case FILE_TYPE_SOURCE:
+ Functions = ConversionTable->SourceFunctions;
+ StringTable = ConversionTable->SourceStringTable;
+ LineTable = ConversionTable->SourceLineTable;
+ ConditionalTable = ConversionTable->SourceConditionalTable;
+ MacroTable = ConversionTable->SourceMacroTable;
+ StructTable = ConversionTable->SourceStructTable;
+ break;
+
+ case FILE_TYPE_HEADER:
+ Functions = ConversionTable->HeaderFunctions;
+ StringTable = ConversionTable->HeaderStringTable;
+ LineTable = ConversionTable->HeaderLineTable;
+ ConditionalTable = ConversionTable->HeaderConditionalTable;
+ MacroTable = ConversionTable->HeaderMacroTable;
+ StructTable = ConversionTable->HeaderStructTable;
+ break;
+
+ default:
+ printf ("Unknown file type, cannot process\n");
+ return;
+ }
+
+
+ Gbl_StructDefs = strstr (FileBuffer, "/* acpisrc:StructDefs");
+ Gbl_Files++;
+ VERBOSE_PRINT (("Processing %u bytes\n",
+ (unsigned int) strlen (FileBuffer)));
+
+ if (ConversionTable->LowerCaseTable)
+ {
+ for (i = 0; ConversionTable->LowerCaseTable[i].Identifier; i++)
+ {
+ AsLowerCaseString (ConversionTable->LowerCaseTable[i].Identifier,
+ FileBuffer);
+ }
+ }
+
+ /* Process all the string replacements */
+
+ if (StringTable)
+ {
+ for (i = 0; StringTable[i].Target; i++)
+ {
+ AsReplaceString (StringTable[i].Target, StringTable[i].Replacement,
+ StringTable[i].Type, FileBuffer);
+ }
+ }
+
+ if (LineTable)
+ {
+ for (i = 0; LineTable[i].Identifier; i++)
+ {
+ AsRemoveLine (FileBuffer, LineTable[i].Identifier);
+ }
+ }
+
+ if (ConditionalTable)
+ {
+ for (i = 0; ConditionalTable[i].Identifier; i++)
+ {
+ AsRemoveConditionalCompile (FileBuffer, ConditionalTable[i].Identifier);
+ }
+ }
+
+ if (MacroTable)
+ {
+ for (i = 0; MacroTable[i].Identifier; i++)
+ {
+ AsRemoveMacro (FileBuffer, MacroTable[i].Identifier);
+ }
+ }
+
+ if (StructTable)
+ {
+ for (i = 0; StructTable[i].Identifier; i++)
+ {
+ AsInsertPrefix (FileBuffer, StructTable[i].Identifier, StructTable[i].Type);
+ }
+ }
+
+ /* Process the function table */
+
+ for (i = 0; i < 32; i++)
+ {
+ /* Decode the function bitmap */
+
+ switch ((1 << i) & Functions)
+ {
+ case 0:
+ /* This function not configured */
+ break;
+
+
+ case CVT_COUNT_TABS:
+
+ AsCountTabs (FileBuffer, Filename);
+ break;
+
+
+ case CVT_COUNT_NON_ANSI_COMMENTS:
+
+ AsCountNonAnsiComments (FileBuffer, Filename);
+ break;
+
+
+ case CVT_CHECK_BRACES:
+
+ AsCheckForBraces (FileBuffer, Filename);
+ break;
+
+
+ case CVT_TRIM_LINES:
+
+ AsTrimLines (FileBuffer, Filename);
+ break;
+
+
+ case CVT_COUNT_LINES:
+
+ AsCountSourceLines (FileBuffer, Filename);
+ break;
+
+
+ case CVT_BRACES_ON_SAME_LINE:
+
+ AsBracesOnSameLine (FileBuffer);
+ break;
+
+
+ case CVT_MIXED_CASE_TO_UNDERSCORES:
+
+ AsMixedCaseToUnderscores (FileBuffer);
+ break;
+
+
+ case CVT_LOWER_CASE_IDENTIFIERS:
+
+ AsLowerCaseIdentifiers (FileBuffer);
+ break;
+
+
+ case CVT_REMOVE_DEBUG_MACROS:
+
+ AsRemoveDebugMacros (FileBuffer);
+ break;
+
+
+ case CVT_TRIM_WHITESPACE:
+
+ AsTrimWhitespace (FileBuffer);
+ break;
+
+
+ case CVT_REMOVE_EMPTY_BLOCKS:
+
+ AsRemoveEmptyBlocks (FileBuffer, Filename);
+ break;
+
+
+ case CVT_REDUCE_TYPEDEFS:
+
+ AsReduceTypedefs (FileBuffer, "typedef union");
+ AsReduceTypedefs (FileBuffer, "typedef struct");
+ break;
+
+
+ case CVT_SPACES_TO_TABS4:
+
+ AsTabify4 (FileBuffer);
+ break;
+
+
+ case CVT_SPACES_TO_TABS8:
+
+ AsTabify8 (FileBuffer);
+ break;
+
+ case CVT_COUNT_SHORTMULTILINE_COMMENTS:
+
+#ifdef ACPI_FUTURE_IMPLEMENTATION
+ AsTrimComments (FileBuffer, Filename);
+#endif
+ break;
+
+ default:
+
+ printf ("Unknown conversion subfunction opcode\n");
+ break;
+ }
+ }
+
+ if (ConversionTable->NewHeader)
+ {
+ AsReplaceHeader (FileBuffer, ConversionTable->NewHeader);
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsProcessOneFile
+ *
+ * DESCRIPTION: Process one source file. The file is opened, read entirely
+ * into a buffer, converted, then written to a new file.
+ *
+ ******************************************************************************/
+
+ACPI_NATIVE_INT
+AsProcessOneFile (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *SourcePath,
+ char *TargetPath,
+ int MaxPathLength,
+ char *Filename,
+ ACPI_NATIVE_INT FileType)
+{
+ char *Pathname;
+ char *OutPathname = NULL;
+
+
+ /* Allocate a file pathname buffer for both source and target */
+
+ Pathname = calloc (MaxPathLength + strlen (Filename) + 2, 1);
+ if (!Pathname)
+ {
+ printf ("Could not allocate buffer for file pathnames\n");
+ return -1;
+ }
+
+ Gbl_FileType = FileType;
+
+ /* Generate the source pathname and read the file */
+
+ if (SourcePath)
+ {
+ strcpy (Pathname, SourcePath);
+ strcat (Pathname, "/");
+ }
+
+ strcat (Pathname, Filename);
+
+ if (AsGetFile (Pathname, &Gbl_FileBuffer, &Gbl_FileSize))
+ {
+ return -1;
+ }
+
+ Gbl_HeaderSize = 0;
+ if (strstr (Filename, ".asl"))
+ {
+ Gbl_HeaderSize = LINES_IN_ASL_HEADER; /* Lines in default ASL header */
+ }
+ else if (strstr (Gbl_FileBuffer, LEGAL_HEADER_SIGNATURE))
+ {
+ Gbl_HeaderSize = LINES_IN_LEGAL_HEADER; /* Normal C file and H header */
+ }
+ else if (strstr (Gbl_FileBuffer, LINUX_HEADER_SIGNATURE))
+ {
+ Gbl_HeaderSize = LINES_IN_LINUX_HEADER; /* Linuxized C file and H header */
+ }
+
+ /* Process the file in the buffer */
+
+ Gbl_MadeChanges = FALSE;
+ if (!Gbl_IgnoreLoneLineFeeds && Gbl_HasLoneLineFeeds)
+ {
+ /*
+ * All lone LFs will be converted to CR/LF
+ * (when file is written, Windows version only)
+ */
+ printf ("Converting lone linefeeds\n");
+ Gbl_MadeChanges = TRUE;
+ }
+
+ AsConvertFile (ConversionTable, Gbl_FileBuffer, Pathname, FileType);
+
+ if (!(ConversionTable->Flags & FLG_NO_FILE_OUTPUT))
+ {
+ if (!(Gbl_Overwrite && !Gbl_MadeChanges))
+ {
+ /* Generate the target pathname and write the file */
+
+ OutPathname = calloc (MaxPathLength + strlen (Filename) + 2 + strlen (TargetPath), 1);
+ if (!OutPathname)
+ {
+ printf ("Could not allocate buffer for file pathnames\n");
+ return -1;
+ }
+
+ strcpy (OutPathname, TargetPath);
+ if (SourcePath)
+ {
+ strcat (OutPathname, "/");
+ strcat (OutPathname, Filename);
+ }
+
+ AsPutFile (OutPathname, Gbl_FileBuffer, ConversionTable->Flags);
+ }
+ }
+
+ free (Gbl_FileBuffer);
+ free (Pathname);
+ if (OutPathname)
+ {
+ free (OutPathname);
+ }
+
+ return 0;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsCheckForDirectory
+ *
+ * DESCRIPTION: Check if the current file is a valid directory. If not,
+ * construct the full pathname for the source and target paths.
+ * Checks for the dot and dot-dot files (they are ignored)
+ *
+ ******************************************************************************/
+
+ACPI_NATIVE_INT
+AsCheckForDirectory (
+ char *SourceDirPath,
+ char *TargetDirPath,
+ char *Filename,
+ char **SourcePath,
+ char **TargetPath)
+{
+ char *SrcPath;
+ char *TgtPath;
+
+
+ if (!(strcmp (Filename, ".")) ||
+ !(strcmp (Filename, "..")))
+ {
+ return -1;
+ }
+
+ SrcPath = calloc (strlen (SourceDirPath) + strlen (Filename) + 2, 1);
+ if (!SrcPath)
+ {
+ printf ("Could not allocate buffer for directory source pathname\n");
+ return -1;
+ }
+
+ TgtPath = calloc (strlen (TargetDirPath) + strlen (Filename) + 2, 1);
+ if (!TgtPath)
+ {
+ printf ("Could not allocate buffer for directory target pathname\n");
+ free (SrcPath);
+ return -1;
+ }
+
+ strcpy (SrcPath, SourceDirPath);
+ strcat (SrcPath, "/");
+ strcat (SrcPath, Filename);
+
+ strcpy (TgtPath, TargetDirPath);
+ strcat (TgtPath, "/");
+ strcat (TgtPath, Filename);
+
+ *SourcePath = SrcPath;
+ *TargetPath = TgtPath;
+ return 0;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsGetFile
+ *
+ * DESCRIPTION: Open a file and read it entirely into a an allocated buffer
+ *
+ ******************************************************************************/
+
+int
+AsGetFile (
+ char *Filename,
+ char **FileBuffer,
+ UINT32 *FileSize)
+{
+
+ int FileHandle;
+ UINT32 Size;
+ char *Buffer;
+
+
+ /* Binary mode leaves CR/LF pairs */
+
+ FileHandle = open (Filename, O_BINARY | O_RDONLY);
+ if (!FileHandle)
+ {
+ printf ("Could not open %s\n", Filename);
+ return -1;
+ }
+
+ if (fstat (FileHandle, &Gbl_StatBuf))
+ {
+ printf ("Could not get file status for %s\n", Filename);
+ goto ErrorExit;
+ }
+
+ /*
+ * Create a buffer for the entire file
+ * Add plenty extra buffer to accomodate string replacements
+ */
+ Size = Gbl_StatBuf.st_size;
+ Gbl_TotalSize += Size;
+
+ Buffer = calloc (Size * 2, 1);
+ if (!Buffer)
+ {
+ printf ("Could not allocate buffer of size %u\n", Size * 2);
+ goto ErrorExit;
+ }
+
+ /* Read the entire file */
+
+ Size = read (FileHandle, Buffer, Size);
+ if (Size == -1)
+ {
+ printf ("Could not read the input file %s\n", Filename);
+ goto ErrorExit;
+ }
+
+ Buffer [Size] = 0; /* Null terminate the buffer */
+ close (FileHandle);
+
+ /* Check for unix contamination */
+
+ Gbl_HasLoneLineFeeds = AsDetectLoneLineFeeds (Filename, Buffer);
+
+ /*
+ * Convert all CR/LF pairs to LF only. We do this locally so that
+ * this code is portable across operating systems.
+ */
+ AsConvertToLineFeeds (Buffer);
+
+ *FileBuffer = Buffer;
+ *FileSize = Size;
+
+ return 0;
+
+
+ErrorExit:
+
+ close (FileHandle);
+ return -1;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsPutFile
+ *
+ * DESCRIPTION: Create a new output file and write the entire contents of the
+ * buffer to the new file. Buffer must be a zero terminated string
+ *
+ ******************************************************************************/
+
+int
+AsPutFile (
+ char *Pathname,
+ char *FileBuffer,
+ UINT32 SystemFlags)
+{
+ UINT32 FileSize;
+ int DestHandle;
+ int OpenFlags;
+
+
+ /* Create the target file */
+
+ OpenFlags = O_TRUNC | O_CREAT | O_WRONLY | O_BINARY;
+
+ if (!(SystemFlags & FLG_NO_CARRIAGE_RETURNS))
+ {
+ /* Put back the CR before each LF */
+
+ AsInsertCarriageReturns (FileBuffer);
+ }
+
+ DestHandle = open (Pathname, OpenFlags, S_IREAD | S_IWRITE);
+ if (DestHandle == -1)
+ {
+ perror ("Could not create destination file");
+ printf ("Could not create destination file \"%s\"\n", Pathname);
+ return -1;
+ }
+
+ /* Write the buffer to the file */
+
+ FileSize = strlen (FileBuffer);
+ write (DestHandle, FileBuffer, FileSize);
+
+ close (DestHandle);
+
+ return 0;
+}
+
+
diff --git a/source/tools/acpisrc/asmain.c b/source/tools/acpisrc/asmain.c
new file mode 100644
index 0000000000000..baf4e2fc34c7a
--- /dev/null
+++ b/source/tools/acpisrc/asmain.c
@@ -0,0 +1,457 @@
+
+/******************************************************************************
+ *
+ * Module Name: asmain - Main module for the acpi source processor utility
+ *
+ *****************************************************************************/
+
+/*
+ * 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.
+ */
+
+
+#include "acpisrc.h"
+#include "acapps.h"
+
+/* Local prototypes */
+
+int
+AsStricmp (
+ char *String1,
+ char *String2);
+
+int
+AsExaminePaths (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *Source,
+ char *Target,
+ UINT32 *SourceFileType);
+
+void
+AsDisplayStats (
+ void);
+
+void
+AsDisplayUsage (
+ void);
+
+/* Globals */
+
+UINT32 Gbl_Tabs = 0;
+UINT32 Gbl_MissingBraces = 0;
+UINT32 Gbl_NonAnsiComments = 0;
+UINT32 Gbl_Files = 0;
+UINT32 Gbl_WhiteLines = 0;
+UINT32 Gbl_CommentLines = 0;
+UINT32 Gbl_SourceLines = 0;
+UINT32 Gbl_LongLines = 0;
+UINT32 Gbl_TotalLines = 0;
+UINT32 Gbl_TotalSize = 0;
+UINT32 Gbl_HeaderLines = 0;
+UINT32 Gbl_HeaderSize = 0;
+void *Gbl_StructDefs = NULL;
+
+struct stat Gbl_StatBuf;
+char *Gbl_FileBuffer;
+UINT32 Gbl_FileSize;
+UINT32 Gbl_FileType;
+BOOLEAN Gbl_VerboseMode = FALSE;
+BOOLEAN Gbl_QuietMode = FALSE;
+BOOLEAN Gbl_BatchMode = FALSE;
+BOOLEAN Gbl_DebugStatementsMode = FALSE;
+BOOLEAN Gbl_MadeChanges = FALSE;
+BOOLEAN Gbl_Overwrite = FALSE;
+BOOLEAN Gbl_WidenDeclarations = FALSE;
+BOOLEAN Gbl_IgnoreLoneLineFeeds = FALSE;
+BOOLEAN Gbl_HasLoneLineFeeds = FALSE;
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsStricmp
+ *
+ * DESCRIPTION: Implementation of the non-ANSI stricmp function (compare
+ * strings with no case sensitivity)
+ *
+ ******************************************************************************/
+
+int
+AsStricmp (
+ char *String1,
+ char *String2)
+{
+ int c1;
+ int c2;
+
+
+ do
+ {
+ c1 = tolower ((int) *String1);
+ c2 = tolower ((int) *String2);
+
+ String1++;
+ String2++;
+ }
+ while ((c1 == c2) && (c1));
+
+ return (c1 - c2);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsExaminePaths
+ *
+ * DESCRIPTION: Source and Target pathname verification and handling
+ *
+ ******************************************************************************/
+
+int
+AsExaminePaths (
+ ACPI_CONVERSION_TABLE *ConversionTable,
+ char *Source,
+ char *Target,
+ UINT32 *SourceFileType)
+{
+ int Status;
+ char Response;
+
+
+ Status = stat (Source, &Gbl_StatBuf);
+ if (Status)
+ {
+ printf ("Source path \"%s\" does not exist\n", Source);
+ return -1;
+ }
+
+ /* Return the filetype -- file or a directory */
+
+ *SourceFileType = 0;
+ if (Gbl_StatBuf.st_mode & S_IFDIR)
+ {
+ *SourceFileType = S_IFDIR;
+ }
+
+ /*
+ * If we are in no-output mode or in batch mode, we are done
+ */
+ if ((ConversionTable->Flags & FLG_NO_FILE_OUTPUT) ||
+ (Gbl_BatchMode))
+ {
+ return 0;
+ }
+
+ if (!AsStricmp (Source, Target))
+ {
+ printf ("Target path is the same as the source path, overwrite?\n");
+ scanf ("%c", &Response);
+
+ /* Check response */
+
+ if ((char) Response != 'y')
+ {
+ return -1;
+ }
+
+ Gbl_Overwrite = TRUE;
+ }
+ else
+ {
+ Status = stat (Target, &Gbl_StatBuf);
+ if (!Status)
+ {
+ printf ("Target path already exists, overwrite?\n");
+ scanf ("%c", &Response);
+
+ /* Check response */
+
+ if ((char) Response != 'y')
+ {
+ return -1;
+ }
+ }
+ }
+
+ return 0;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsDisplayStats
+ *
+ * DESCRIPTION: Display global statistics gathered during translation
+ *
+ ******************************************************************************/
+
+void
+AsDisplayStats (
+ void)
+{
+
+ if (Gbl_QuietMode)
+ {
+ return;
+ }
+
+ printf ("\nAcpiSrc statistics:\n\n");
+ printf ("%8u Files processed\n", Gbl_Files);
+
+ if (!Gbl_Files)
+ {
+ return;
+ }
+
+ printf ("%8u Total bytes (%.1fK/file)\n",
+ Gbl_TotalSize, ((double) Gbl_TotalSize/Gbl_Files)/1024);
+ printf ("%8u Tabs found\n", Gbl_Tabs);
+ printf ("%8u Missing if/else braces\n", Gbl_MissingBraces);
+ printf ("%8u Non-ANSI comments found\n", Gbl_NonAnsiComments);
+ printf ("%8u Total Lines\n", Gbl_TotalLines);
+ printf ("%8u Lines of code\n", Gbl_SourceLines);
+ printf ("%8u Lines of non-comment whitespace\n", Gbl_WhiteLines);
+ printf ("%8u Lines of comments\n", Gbl_CommentLines);
+ printf ("%8u Long lines found\n", Gbl_LongLines);
+ printf ("%8.1f Ratio of code to whitespace\n",
+ ((float) Gbl_SourceLines / (float) Gbl_WhiteLines));
+ printf ("%8.1f Ratio of code to comments\n",
+ ((float) Gbl_SourceLines / (float) (Gbl_CommentLines + Gbl_NonAnsiComments)));
+
+ if (!Gbl_TotalLines)
+ {
+ return;
+ }
+
+ printf (" %u%% code, %u%% comments, %u%% whitespace, %u%% headers\n",
+ (Gbl_SourceLines * 100) / Gbl_TotalLines,
+ (Gbl_CommentLines * 100) / Gbl_TotalLines,
+ (Gbl_WhiteLines * 100) / Gbl_TotalLines,
+ (Gbl_HeaderLines * 100) / Gbl_TotalLines);
+ return;
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsDisplayUsage
+ *
+ * DESCRIPTION: Usage message
+ *
+ ******************************************************************************/
+
+void
+AsDisplayUsage (
+ void)
+{
+
+ ACPI_USAGE_HEADER ("acpisrc [-c|l|u] [-dsvy] <SourceDir> <DestinationDir>");
+
+ ACPI_OPTION ("-c", "Generate cleaned version of the source");
+ ACPI_OPTION ("-h", "Insert dual-license header into all modules");
+ ACPI_OPTION ("-l", "Generate Linux version of the source");
+ ACPI_OPTION ("-u", "Generate Custom source translation");
+
+ printf ("\n");
+ ACPI_OPTION ("-d", "Leave debug statements in code");
+ ACPI_OPTION ("-s", "Generate source statistics only");
+ ACPI_OPTION ("-v", "Verbose mode");
+ ACPI_OPTION ("-y", "Suppress file overwrite prompts");
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: main
+ *
+ * DESCRIPTION: C main function
+ *
+ ******************************************************************************/
+
+int ACPI_SYSTEM_XFACE
+main (
+ int argc,
+ char *argv[])
+{
+ int j;
+ ACPI_CONVERSION_TABLE *ConversionTable = NULL;
+ char *SourcePath;
+ char *TargetPath;
+ UINT32 FileType;
+
+
+ printf (ACPI_COMMON_SIGNON ("ACPI Source Code Conversion Utility"));
+
+ if (argc < 2)
+ {
+ AsDisplayUsage ();
+ return 0;
+ }
+
+ /* Command line options */
+
+ while ((j = AcpiGetopt (argc, argv, "cdhlqsuvy")) != EOF) switch(j)
+ {
+ case 'l':
+ /* Linux code generation */
+
+ printf ("Creating Linux source code\n");
+ ConversionTable = &LinuxConversionTable;
+ Gbl_WidenDeclarations = TRUE;
+ Gbl_IgnoreLoneLineFeeds = TRUE;
+ break;
+
+ case 'c':
+ /* Cleanup code */
+
+ printf ("Code cleanup\n");
+ ConversionTable = &CleanupConversionTable;
+ break;
+
+ case 'h':
+ /* Inject Dual-license header */
+
+ printf ("Inserting Dual-license header to all modules\n");
+ ConversionTable = &LicenseConversionTable;
+ break;
+
+ case 's':
+ /* Statistics only */
+
+ break;
+
+ case 'u':
+ /* custom conversion */
+
+ printf ("Custom source translation\n");
+ ConversionTable = &CustomConversionTable;
+ break;
+
+ case 'v':
+ /* Verbose mode */
+
+ Gbl_VerboseMode = TRUE;
+ break;
+
+ case 'y':
+ /* Batch mode */
+
+ Gbl_BatchMode = TRUE;
+ break;
+
+ case 'd':
+ /* Leave debug statements in */
+
+ Gbl_DebugStatementsMode = TRUE;
+ break;
+
+ case 'q':
+ /* Quiet mode */
+
+ Gbl_QuietMode = TRUE;
+ break;
+
+ default:
+ AsDisplayUsage ();
+ return -1;
+ }
+
+
+ SourcePath = argv[AcpiGbl_Optind];
+ if (!SourcePath)
+ {
+ printf ("Missing source path\n");
+ AsDisplayUsage ();
+ return -1;
+ }
+
+ TargetPath = argv[AcpiGbl_Optind+1];
+
+ if (!ConversionTable)
+ {
+ /* Just generate statistics. Ignore target path */
+
+ TargetPath = SourcePath;
+
+ printf ("Source code statistics only\n");
+ ConversionTable = &StatsConversionTable;
+ }
+ else if (!TargetPath)
+ {
+ TargetPath = SourcePath;
+ }
+
+ if (Gbl_DebugStatementsMode)
+ {
+ ConversionTable->SourceFunctions &= ~CVT_REMOVE_DEBUG_MACROS;
+ }
+
+ /* Check source and target paths and files */
+
+ if (AsExaminePaths (ConversionTable, SourcePath, TargetPath, &FileType))
+ {
+ return -1;
+ }
+
+ /* Source/target can be either directories or a files */
+
+ if (FileType == S_IFDIR)
+ {
+ /* Process the directory tree */
+
+ AsProcessTree (ConversionTable, SourcePath, TargetPath);
+ }
+ else
+ {
+ /* Process a single file */
+
+ /* Differentiate between source and header files */
+
+ if (strstr (SourcePath, ".h"))
+ {
+ AsProcessOneFile (ConversionTable, NULL, TargetPath, 0, SourcePath, FILE_TYPE_HEADER);
+ }
+ else
+ {
+ AsProcessOneFile (ConversionTable, NULL, TargetPath, 0, SourcePath, FILE_TYPE_SOURCE);
+ }
+ }
+
+ /* Always display final summary and stats */
+
+ AsDisplayStats ();
+
+ return 0;
+}
diff --git a/source/tools/acpisrc/asremove.c b/source/tools/acpisrc/asremove.c
new file mode 100644
index 0000000000000..8fe29e158a2a7
--- /dev/null
+++ b/source/tools/acpisrc/asremove.c
@@ -0,0 +1,616 @@
+
+/******************************************************************************
+ *
+ * Module Name: asremove - Source conversion - removal functions
+ *
+ *****************************************************************************/
+
+/*
+ * 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.
+ */
+
+#include "acpisrc.h"
+
+/* Local prototypes */
+
+void
+AsRemoveStatement (
+ char *Buffer,
+ char *Keyword,
+ UINT32 Type);
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsRemoveStatement
+ *
+ * DESCRIPTION: Remove all statements that contain the given keyword.
+ * Limitations: Removes text from the start of the line that
+ * contains the keyword to the next semicolon. Currently
+ * doesn't ignore comments.
+ *
+ ******************************************************************************/
+
+void
+AsRemoveStatement (
+ char *Buffer,
+ char *Keyword,
+ UINT32 Type)
+{
+ char *SubString;
+ char *SubBuffer;
+ int KeywordLength;
+
+
+ KeywordLength = strlen (Keyword);
+ SubBuffer = Buffer;
+ SubString = Buffer;
+
+
+ while (SubString)
+ {
+ SubString = strstr (SubBuffer, Keyword);
+
+ if (SubString)
+ {
+ SubBuffer = SubString;
+
+ if ((Type == REPLACE_WHOLE_WORD) &&
+ (!AsMatchExactWord (SubString, KeywordLength)))
+ {
+ SubBuffer++;
+ continue;
+ }
+
+ /* Find start of this line */
+
+ while (*SubString != '\n')
+ {
+ SubString--;
+ }
+ SubString++;
+
+ /* Find end of this statement */
+
+ SubBuffer = AsSkipPastChar (SubBuffer, ';');
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ /* Find end of this line */
+
+ SubBuffer = AsSkipPastChar (SubBuffer, '\n');
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ /* If next line is blank, remove it too */
+
+ if (*SubBuffer == '\n')
+ {
+ SubBuffer++;
+ }
+
+ /* Remove the lines */
+
+ SubBuffer = AsRemoveData (SubString, SubBuffer);
+ }
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsRemoveConditionalCompile
+ *
+ * DESCRIPTION: Remove a "#ifdef" statement, and all text that it encompasses.
+ * Limitations: cannot handle nested ifdefs.
+ *
+ ******************************************************************************/
+
+void
+AsRemoveConditionalCompile (
+ char *Buffer,
+ char *Keyword)
+{
+ char *SubString;
+ char *SubBuffer;
+ char *IfPtr;
+ char *EndifPtr;
+ char *ElsePtr;
+ char *Comment;
+ int KeywordLength;
+
+
+ KeywordLength = strlen (Keyword);
+ SubBuffer = Buffer;
+ SubString = Buffer;
+
+
+ while (SubString)
+ {
+ SubBuffer = strstr (SubString, Keyword);
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ /*
+ * Check for translation escape string -- means to ignore
+ * blocks of code while replacing
+ */
+ Comment = strstr (SubString, AS_START_IGNORE);
+
+ if ((Comment) &&
+ (Comment < SubBuffer))
+ {
+ SubString = strstr (Comment, AS_STOP_IGNORE);
+ if (!SubString)
+ {
+ return;
+ }
+
+ SubString += 3;
+ continue;
+ }
+
+ /* Check for ordinary comment */
+
+ Comment = strstr (SubString, "/*");
+
+ if ((Comment) &&
+ (Comment < SubBuffer))
+ {
+ SubString = strstr (Comment, "*/");
+ if (!SubString)
+ {
+ return;
+ }
+
+ SubString += 2;
+ continue;
+ }
+
+ SubString = SubBuffer;
+ if (!AsMatchExactWord (SubString, KeywordLength))
+ {
+ SubString++;
+ continue;
+ }
+
+ /* Find start of this line */
+
+ while (*SubString != '\n' && (SubString > Buffer))
+ {
+ SubString--;
+ }
+ SubString++;
+
+ /* Find the "#ifxxxx" */
+
+ IfPtr = strstr (SubString, "#if");
+ if (!IfPtr)
+ {
+ return;
+ }
+
+ if (IfPtr > SubBuffer)
+ {
+ /* Not the right #if */
+
+ SubString = SubBuffer + strlen (Keyword);
+ continue;
+ }
+
+ /* Find closing #endif or #else */
+
+ EndifPtr = strstr (SubBuffer, "#endif");
+ if (!EndifPtr)
+ {
+ /* There has to be an #endif */
+
+ return;
+ }
+
+ ElsePtr = strstr (SubBuffer, "#else");
+ if ((ElsePtr) &&
+ (EndifPtr > ElsePtr))
+ {
+ /* This #ifdef contains an #else clause */
+ /* Find end of this line */
+
+ SubBuffer = AsSkipPastChar (ElsePtr, '\n');
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ /* Remove the #ifdef .... #else code */
+
+ AsRemoveData (SubString, SubBuffer);
+
+ /* Next, we will remove the #endif statement */
+
+ EndifPtr = strstr (SubString, "#endif");
+ if (!EndifPtr)
+ {
+ /* There has to be an #endif */
+
+ return;
+ }
+
+ SubString = EndifPtr;
+ }
+
+ /* Remove the ... #endif part */
+ /* Find end of this line */
+
+ SubBuffer = AsSkipPastChar (EndifPtr, '\n');
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ /* Remove the lines */
+
+ SubBuffer = AsRemoveData (SubString, SubBuffer);
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsRemoveMacro
+ *
+ * DESCRIPTION: Remove every line that contains the keyword. Does not
+ * skip comments.
+ *
+ ******************************************************************************/
+
+void
+AsRemoveMacro (
+ char *Buffer,
+ char *Keyword)
+{
+ char *SubString;
+ char *SubBuffer;
+ int NestLevel;
+
+
+ SubBuffer = Buffer;
+ SubString = Buffer;
+
+
+ while (SubString)
+ {
+ SubString = strstr (SubBuffer, Keyword);
+
+ if (SubString)
+ {
+ SubBuffer = SubString;
+
+ /* Find start of the macro parameters */
+
+ while (*SubString != '(')
+ {
+ SubString++;
+ }
+ SubString++;
+
+ /* Remove the macro name and opening paren */
+
+ SubString = AsRemoveData (SubBuffer, SubString);
+
+ NestLevel = 1;
+ while (*SubString)
+ {
+ if (*SubString == '(')
+ {
+ NestLevel++;
+ }
+ else if (*SubString == ')')
+ {
+ NestLevel--;
+ }
+
+ SubString++;
+
+ if (NestLevel == 0)
+ {
+ break;
+ }
+ }
+
+ /* Remove the closing paren */
+
+ SubBuffer = AsRemoveData (SubString-1, SubString);
+ }
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsRemoveLine
+ *
+ * DESCRIPTION: Remove every line that contains the keyword. Does not
+ * skip comments.
+ *
+ ******************************************************************************/
+
+void
+AsRemoveLine (
+ char *Buffer,
+ char *Keyword)
+{
+ char *SubString;
+ char *SubBuffer;
+
+
+ SubBuffer = Buffer;
+ SubString = Buffer;
+
+
+ while (SubString)
+ {
+ SubString = strstr (SubBuffer, Keyword);
+
+ if (SubString)
+ {
+ SubBuffer = SubString;
+
+ /* Find start of this line */
+
+ while (*SubString != '\n')
+ {
+ SubString--;
+ }
+ SubString++;
+
+ /* Find end of this line */
+
+ SubBuffer = AsSkipPastChar (SubBuffer, '\n');
+ if (!SubBuffer)
+ {
+ return;
+ }
+
+ /* Remove the line */
+
+ SubBuffer = AsRemoveData (SubString, SubBuffer);
+ }
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsReduceTypedefs
+ *
+ * DESCRIPTION: Eliminate certain typedefs
+ *
+ ******************************************************************************/
+
+void
+AsReduceTypedefs (
+ char *Buffer,
+ char *Keyword)
+{
+ char *SubString;
+ char *SubBuffer;
+ int NestLevel;
+
+
+ SubBuffer = Buffer;
+ SubString = Buffer;
+
+
+ while (SubString)
+ {
+ SubString = strstr (SubBuffer, Keyword);
+
+ if (SubString)
+ {
+ /* Remove the typedef itself */
+
+ SubBuffer = SubString + strlen ("typedef") + 1;
+ SubBuffer = AsRemoveData (SubString, SubBuffer);
+
+ /* Find the opening brace of the struct or union */
+
+ while (*SubString != '{')
+ {
+ SubString++;
+ }
+ SubString++;
+
+ /* Find the closing brace. Handles nested braces */
+
+ NestLevel = 1;
+ while (*SubString)
+ {
+ if (*SubString == '{')
+ {
+ NestLevel++;
+ }
+ else if (*SubString == '}')
+ {
+ NestLevel--;
+ }
+
+ SubString++;
+
+ if (NestLevel == 0)
+ {
+ break;
+ }
+ }
+
+ /* Remove an extra line feed if present */
+
+ if (!strncmp (SubString - 3, "\n\n", 2))
+ {
+ *(SubString -2) = '}';
+ SubString--;
+ }
+
+ /* Find the end of the typedef name */
+
+ SubBuffer = AsSkipUntilChar (SubString, ';');
+
+ /* And remove the typedef name */
+
+ SubBuffer = AsRemoveData (SubString, SubBuffer);
+ }
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsRemoveEmptyBlocks
+ *
+ * DESCRIPTION: Remove any C blocks (e.g., if {}) that contain no code. This
+ * can happen as a result of removing lines such as DEBUG_PRINT.
+ *
+ ******************************************************************************/
+
+void
+AsRemoveEmptyBlocks (
+ char *Buffer,
+ char *Filename)
+{
+ char *SubBuffer;
+ char *BlockStart;
+ BOOLEAN EmptyBlock = TRUE;
+ BOOLEAN AnotherPassRequired = TRUE;
+ UINT32 BlockCount = 0;
+
+
+ while (AnotherPassRequired)
+ {
+ SubBuffer = Buffer;
+ AnotherPassRequired = FALSE;
+
+ while (*SubBuffer)
+ {
+ if (*SubBuffer == '{')
+ {
+ BlockStart = SubBuffer;
+ EmptyBlock = TRUE;
+
+ SubBuffer++;
+ while (*SubBuffer != '}')
+ {
+ if ((*SubBuffer != ' ') &&
+ (*SubBuffer != '\n'))
+ {
+ EmptyBlock = FALSE;
+ break;
+ }
+ SubBuffer++;
+ }
+
+ if (EmptyBlock)
+ {
+ /* Find start of the first line of the block */
+
+ while (*BlockStart != '\n')
+ {
+ BlockStart--;
+ }
+
+ /* Find end of the last line of the block */
+
+ SubBuffer = AsSkipUntilChar (SubBuffer, '\n');
+ if (!SubBuffer)
+ {
+ break;
+ }
+
+ /* Remove the block */
+
+ SubBuffer = AsRemoveData (BlockStart, SubBuffer);
+ BlockCount++;
+ AnotherPassRequired = TRUE;
+ continue;
+ }
+ }
+
+ SubBuffer++;
+ }
+ }
+
+ if (BlockCount)
+ {
+ Gbl_MadeChanges = TRUE;
+ AsPrint ("Code blocks deleted", BlockCount, Filename);
+ }
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsRemoveDebugMacros
+ *
+ * DESCRIPTION: Remove all "Debug" macros -- macros that produce debug output.
+ *
+ ******************************************************************************/
+
+void
+AsRemoveDebugMacros (
+ char *Buffer)
+{
+ AsRemoveConditionalCompile (Buffer, "ACPI_DEBUG_OUTPUT");
+
+ AsRemoveStatement (Buffer, "ACPI_DEBUG_PRINT", REPLACE_WHOLE_WORD);
+ AsRemoveStatement (Buffer, "ACPI_DEBUG_PRINT_RAW", REPLACE_WHOLE_WORD);
+ AsRemoveStatement (Buffer, "DEBUG_EXEC", REPLACE_WHOLE_WORD);
+ AsRemoveStatement (Buffer, "FUNCTION_ENTRY", REPLACE_WHOLE_WORD);
+ AsRemoveStatement (Buffer, "PROC_NAME", REPLACE_WHOLE_WORD);
+ AsRemoveStatement (Buffer, "FUNCTION_TRACE", REPLACE_SUBSTRINGS);
+ AsRemoveStatement (Buffer, "DUMP_", REPLACE_SUBSTRINGS);
+
+ AsReplaceString ("return_VOID", "return", REPLACE_WHOLE_WORD, Buffer);
+ AsReplaceString ("return_PTR", "return", REPLACE_WHOLE_WORD, Buffer);
+ AsReplaceString ("return_ACPI_STATUS", "return", REPLACE_WHOLE_WORD, Buffer);
+ AsReplaceString ("return_acpi_status", "return", REPLACE_WHOLE_WORD, Buffer);
+ AsReplaceString ("return_VALUE", "return", REPLACE_WHOLE_WORD, Buffer);
+}
+
+
diff --git a/source/tools/acpisrc/astable.c b/source/tools/acpisrc/astable.c
new file mode 100644
index 0000000000000..a1d96d32a83a9
--- /dev/null
+++ b/source/tools/acpisrc/astable.c
@@ -0,0 +1,870 @@
+
+/******************************************************************************
+ *
+ * Module Name: astable - Tables used for source conversion
+ *
+ *****************************************************************************/
+
+/*
+ * 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.
+ */
+
+
+#include "acpisrc.h"
+#include "acapps.h"
+
+
+/******************************************************************************
+ *
+ * Standard/Common translation tables
+ *
+ ******************************************************************************/
+
+
+ACPI_STRING_TABLE StandardDataTypes[] = {
+
+ /* Declarations first */
+
+ {"UINT32 ", "unsigned int", REPLACE_SUBSTRINGS},
+ {"UINT16 ", "unsigned short", REPLACE_SUBSTRINGS},
+ {"UINT8 ", "unsigned char", REPLACE_SUBSTRINGS},
+ {"BOOLEAN ", "unsigned char", REPLACE_SUBSTRINGS},
+
+ /* Now do embedded typecasts */
+
+ {"UINT32", "unsigned int", REPLACE_SUBSTRINGS},
+ {"UINT16", "unsigned short", REPLACE_SUBSTRINGS},
+ {"UINT8", "unsigned char", REPLACE_SUBSTRINGS},
+ {"BOOLEAN", "unsigned char", REPLACE_SUBSTRINGS},
+
+ {"INT32 ", "int ", REPLACE_SUBSTRINGS},
+ {"INT32", "int", REPLACE_SUBSTRINGS},
+ {"INT16", "short", REPLACE_SUBSTRINGS},
+ {"INT8", "char", REPLACE_SUBSTRINGS},
+
+ /* Put back anything we broke (such as anything with _INT32_ in it) */
+
+ {"_int_", "_INT32_", REPLACE_SUBSTRINGS},
+ {"_unsigned int_", "_UINT32_", REPLACE_SUBSTRINGS},
+ {NULL, NULL, 0}
+};
+
+
+/******************************************************************************
+ *
+ * Linux-specific translation tables
+ *
+ ******************************************************************************/
+
+char DualLicenseHeader[] =
+"/*\n"
+" * Copyright (C) 2000 - 2012, Intel Corp.\n"
+" * All rights reserved.\n"
+" *\n"
+" * Redistribution and use in source and binary forms, with or without\n"
+" * modification, are permitted provided that the following conditions\n"
+" * are met:\n"
+" * 1. Redistributions of source code must retain the above copyright\n"
+" * notice, this list of conditions, and the following disclaimer,\n"
+" * without modification.\n"
+" * 2. Redistributions in binary form must reproduce at minimum a disclaimer\n"
+" * substantially similar to the \"NO WARRANTY\" disclaimer below\n"
+" * (\"Disclaimer\") and any redistribution must be conditioned upon\n"
+" * including a substantially similar Disclaimer requirement for further\n"
+" * binary redistribution.\n"
+" * 3. Neither the names of the above-listed copyright holders nor the names\n"
+" * of any contributors may be used to endorse or promote products derived\n"
+" * from this software without specific prior written permission.\n"
+" *\n"
+" * Alternatively, this software may be distributed under the terms of the\n"
+" * GNU General Public License (\"GPL\") version 2 as published by the Free\n"
+" * Software Foundation.\n"
+" *\n"
+" * NO WARRANTY\n"
+" * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS\n"
+" * \"AS IS\" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT\n"
+" * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR\n"
+" * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT\n"
+" * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\n"
+" * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS\n"
+" * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)\n"
+" * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,\n"
+" * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING\n"
+" * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE\n"
+" * POSSIBILITY OF SUCH DAMAGES.\n"
+" */\n";
+
+ACPI_STRING_TABLE LinuxDataTypes[] = {
+
+/*
+ * Extra space is added after the type so there is room to add "struct", "union",
+ * etc. when the existing struct typedefs are eliminated.
+ */
+
+ /* Declarations first - ACPI types and standard C types */
+
+ {"INT64 ", "s64 ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"UINT64 ", "u64 ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"UINT32 ", "u32 ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"INT32 ", "s32 ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"UINT16 ", "u16 ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"INT16 ", "s16 ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"UINT8 ", "u8 ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"BOOLEAN ", "u8 ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"char ", "char ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"void ", "void ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"char * ", "char * ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"void * ", "void * ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"int ", "int ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"FILE ", "FILE ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+ {"size_t ", "size_t ", REPLACE_WHOLE_WORD | EXTRA_INDENT_C},
+
+ /* Now do embedded typecasts */
+
+ {"UINT64", "u64", REPLACE_WHOLE_WORD},
+ {"UINT32", "u32", REPLACE_WHOLE_WORD},
+ {"UINT16", "u16", REPLACE_WHOLE_WORD},
+ {"UINT8", "u8", REPLACE_WHOLE_WORD},
+ {"BOOLEAN", "u8", REPLACE_WHOLE_WORD},
+
+ {"INT64 ", "s64 ", REPLACE_WHOLE_WORD},
+ {"INT64", "s64", REPLACE_WHOLE_WORD},
+ {"INT32 ", "s32 ", REPLACE_WHOLE_WORD},
+ {"INT32", "s32", REPLACE_WHOLE_WORD},
+ {"INT16 ", "s16 ", REPLACE_WHOLE_WORD},
+ {"INT8 ", "s8 ", REPLACE_WHOLE_WORD},
+ {"INT16", "s16", REPLACE_WHOLE_WORD},
+ {"INT8", "s8", REPLACE_WHOLE_WORD},
+
+ /* Include file paths */
+
+ {"\"acpi.h\"", "<acpi/acpi.h>", REPLACE_WHOLE_WORD},
+
+ {NULL, NULL, 0}
+};
+
+ACPI_TYPED_IDENTIFIER_TABLE AcpiIdentifiers[] = {
+
+ {"ACPI_ADR_SPACE_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_ADR_SPACE_SETUP", SRC_TYPE_SIMPLE},
+ {"ACPI_ADR_SPACE_TYPE", SRC_TYPE_SIMPLE},
+ {"ACPI_AML_OPERANDS", SRC_TYPE_UNION},
+ {"ACPI_BIT_REGISTER_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_BUFFER", SRC_TYPE_STRUCT},
+ {"ACPI_BUS_ATTRIBUTE", SRC_TYPE_STRUCT},
+ {"ACPI_CACHE_T", SRC_TYPE_SIMPLE},
+ {"ACPI_CMTABLE_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_COMMON_FACS", SRC_TYPE_STRUCT},
+ {"ACPI_COMMON_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_COMMON_DESCRIPTOR", SRC_TYPE_STRUCT},
+ {"ACPI_COMPATIBLE_ID", SRC_TYPE_STRUCT},
+ {"ACPI_CONNECTION_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_CONTROL_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_CONVERSION_TABLE", SRC_TYPE_STRUCT},
+ {"ACPI_CPU_FLAGS", SRC_TYPE_SIMPLE},
+ {"ACPI_CREATE_FIELD_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_DB_METHOD_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_DEBUG_MEM_BLOCK", SRC_TYPE_STRUCT},
+ {"ACPI_DEBUG_MEM_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_DEBUG_PRINT_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_DESCRIPTOR", SRC_TYPE_UNION},
+ {"ACPI_DEVICE_ID", SRC_TYPE_STRUCT},
+ {"ACPI_DEVICE_ID_LIST", SRC_TYPE_STRUCT},
+ {"ACPI_DEVICE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_DEVICE_WALK_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_DMTABLE_DATA", SRC_TYPE_STRUCT},
+ {"ACPI_DMTABLE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_DMTABLE_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_EVALUATE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_EVENT_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_EVENT_STATUS", SRC_TYPE_SIMPLE},
+ {"ACPI_EVENT_TYPE", SRC_TYPE_SIMPLE},
+ {"ACPI_EXCEPTION_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_EXDUMP_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_EXECUTE_OP", SRC_TYPE_SIMPLE},
+ {"ACPI_EXECUTE_TYPE", SRC_TYPE_SIMPLE},
+ {"ACPI_EXECUTE_WALK", SRC_TYPE_STRUCT},
+ {"ACPI_EXTERNAL_LIST", SRC_TYPE_STRUCT},
+ {"ACPI_EXTERNAL_FILE", SRC_TYPE_STRUCT},
+ {"ACPI_FADT_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_FADT_PM_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_FIELD_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_FIND_CONTEXT", SRC_TYPE_STRUCT},
+ {"ACPI_FIXED_EVENT_HANDLER", SRC_TYPE_STRUCT},
+ {"ACPI_FIXED_EVENT_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GBL_EVENT_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_GENERIC_ADDRESS", SRC_TYPE_STRUCT},
+ {"ACPI_GENERIC_STATE", SRC_TYPE_UNION},
+ {"ACPI_GET_DEVICES_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GPE_BLOCK_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GPE_CALLBACK", SRC_TYPE_SIMPLE},
+ {"ACPI_GPE_DEVICE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GPE_EVENT_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GPE_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_GPE_HANDLER_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GPE_INDEX_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GPE_REGISTER_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GPE_WALK_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_GPE_XRUPT_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_HANDLE", SRC_TYPE_SIMPLE},
+ {"ACPI_HANDLER_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_INIT_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_INTERFACE_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_IDENTIFIER_TABLE", SRC_TYPE_STRUCT},
+ {"ACPI_INIT_WALK_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_INTEGER", SRC_TYPE_SIMPLE},
+ {"ACPI_INTEGER_OVERLAY", SRC_TYPE_STRUCT},
+ {"ACPI_INTEGRITY_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_INTERFACE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_INTERNAL_METHOD", SRC_TYPE_SIMPLE},
+ {"ACPI_INTERPRETER_MODE", SRC_TYPE_SIMPLE},
+ {"ACPI_IO_ADDRESS", SRC_TYPE_SIMPLE},
+ {"ACPI_IO_ATTRIBUTE", SRC_TYPE_STRUCT},
+ {"ACPI_MEM_SPACE_CONTEXT", SRC_TYPE_STRUCT},
+ {"ACPI_MEMORY_ATTRIBUTE", SRC_TYPE_STRUCT},
+ {"ACPI_MEMORY_LIST", SRC_TYPE_STRUCT},
+ {"ACPI_MUTEX", SRC_TYPE_SIMPLE},
+ {"ACPI_MUTEX_HANDLE", SRC_TYPE_SIMPLE},
+ {"ACPI_MUTEX_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_NAME", SRC_TYPE_SIMPLE},
+ {"ACPI_NAME_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_NAME_UNION", SRC_TYPE_UNION},
+ {"ACPI_NAMESPACE_NODE", SRC_TYPE_STRUCT},
+ {"ACPI_NAMESTRING_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_NATIVE_INT", SRC_TYPE_SIMPLE},
+ {"ACPI_NATIVE_UINT", SRC_TYPE_SIMPLE},
+ {"ACPI_NOTIFY_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_NOTIFY_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_NS_SEARCH_DATA", SRC_TYPE_STRUCT},
+ {"ACPI_OBJ_INFO_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT", SRC_TYPE_UNION},
+ {"ACPI_OBJECT_ADDR_HANDLER", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_BANK_FIELD", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_BUFFER", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_BUFFER_FIELD", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_CACHE_LIST", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_COMMON", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_DATA", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_DEVICE", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_EVENT", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_EXTRA", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_FIELD_COMMON", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_OBJECT_INDEX_FIELD", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_INTEGER", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_LIST", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_METHOD", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_MUTEX", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_NOTIFY_COMMON", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_NOTIFY_HANDLER", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_PACKAGE", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_POWER_RESOURCE", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_PROCESSOR", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_REFERENCE", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_REGION", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_REGION_FIELD", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_STRING", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_THERMAL_ZONE", SRC_TYPE_STRUCT},
+ {"ACPI_OBJECT_TYPE", SRC_TYPE_SIMPLE},
+ {"ACPI_OBJECT_TYPE8", SRC_TYPE_SIMPLE},
+ {"ACPI_OP_WALK_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_OPCODE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_OPERAND_OBJECT", SRC_TYPE_UNION},
+ {"ACPI_OSD_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_OSD_EXEC_CALLBACK", SRC_TYPE_SIMPLE},
+ {"ACPI_OWNER_ID", SRC_TYPE_SIMPLE},
+ {"ACPI_PACKAGE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_PACKAGE_INFO2", SRC_TYPE_STRUCT},
+ {"ACPI_PACKAGE_INFO3", SRC_TYPE_STRUCT},
+ {"ACPI_PARSE_DOWNWARDS", SRC_TYPE_SIMPLE},
+ {"ACPI_PARSE_OBJ_ASL", SRC_TYPE_STRUCT},
+ {"ACPI_PARSE_OBJ_COMMON", SRC_TYPE_STRUCT},
+ {"ACPI_PARSE_OBJ_NAMED", SRC_TYPE_STRUCT},
+ {"ACPI_PARSE_OBJECT", SRC_TYPE_UNION},
+ {"ACPI_PARSE_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_PARSE_UPWARDS", SRC_TYPE_SIMPLE},
+ {"ACPI_PARSE_VALUE", SRC_TYPE_UNION},
+ {"ACPI_PCI_DEVICE", SRC_TYPE_STRUCT},
+ {"ACPI_PCI_ID", SRC_TYPE_STRUCT},
+ {"ACPI_PCI_ROUTING_TABLE", SRC_TYPE_STRUCT},
+ {"ACPI_PHYSICAL_ADDRESS", SRC_TYPE_SIMPLE},
+ {"ACPI_PKG_CALLBACK", SRC_TYPE_SIMPLE},
+ {"ACPI_PKG_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_PKG_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_PMTT_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_POINTER", SRC_TYPE_STRUCT},
+ {"ACPI_POINTERS", SRC_TYPE_UNION},
+ {"ACPI_PORT_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_PREDEFINED_DATA", SRC_TYPE_STRUCT},
+ {"ACPI_PREDEFINED_INFO", SRC_TYPE_UNION},
+ {"ACPI_PREDEFINED_NAMES", SRC_TYPE_STRUCT},
+ {"ACPI_PSCOPE_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_REPAIR_FUNCTION", SRC_TYPE_SIMPLE},
+ {"ACPI_REPAIR_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_RESOURCE_ADDRESS", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_ADDRESS16", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_ADDRESS32", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_ADDRESS64", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_COMMON_SERIALBUS", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_EXTENDED_ADDRESS64", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_ATTRIBUTE", SRC_TYPE_UNION},
+ {"ACPI_RESOURCE_DATA", SRC_TYPE_UNION},
+ {"ACPI_RESOURCE_DMA", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_END_TAG", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_EXTENDED_IRQ", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_FIXED_DMA", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_FIXED_IO", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_FIXED_MEMORY32", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_GENERIC_REGISTER", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_GPIO", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_I2C_SERIALBUS", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_IO", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_IRQ", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_MEMORY24", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_MEMORY32", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_SOURCE", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_SPI_SERIALBUS", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_START_DEPENDENT", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_TAG", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_TYPE", SRC_TYPE_SIMPLE},
+ {"ACPI_RESOURCE_UART_SERIALBUS", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_VENDOR", SRC_TYPE_STRUCT},
+ {"ACPI_RESOURCE_VENDOR_TYPED", SRC_TYPE_STRUCT},
+ {"ACPI_RESULT_VALUES", SRC_TYPE_STRUCT},
+ {"ACPI_ROUND_UP_TO_32_BIT", SRC_TYPE_SIMPLE},
+ {"ACPI_RSCONVERT_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_RSDUMP_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_RW_LOCK", SRC_TYPE_STRUCT},
+ {"ACPI_S3PT_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_SCOPE_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_SEMAPHORE", SRC_TYPE_SIMPLE},
+ {"ACPI_SIGNAL_FATAL_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_SIZE", SRC_TYPE_SIMPLE},
+ {"ACPI_SLEEP_FUNCTION", SRC_TYPE_SIMPLE},
+ {"ACPI_SLEEP_FUNCTIONS", SRC_TYPE_STRUCT},
+ {"ACPI_SPINLOCK", SRC_TYPE_SIMPLE},
+ {"ACPI_STATISTICS", SRC_TYPE_STRUCT},
+ {"ACPI_STATUS", SRC_TYPE_SIMPLE},
+ {"ACPI_STRING", SRC_TYPE_SIMPLE},
+ {"ACPI_STRING_TABLE", SRC_TYPE_STRUCT},
+ {"ACPI_SUBTABLE_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_SYSTEM_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_DESC", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_HANDLER", SRC_TYPE_SIMPLE},
+ {"ACPI_TABLE_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_LIST", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_SUPPORT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_TYPE", SRC_TYPE_SIMPLE},
+ {"ACPI_TAG_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_THREAD_ID", SRC_TYPE_SIMPLE},
+ {"ACPI_THREAD_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_TYPED_IDENTIFIER_TABLE", SRC_TYPE_STRUCT},
+ {"ACPI_UINTPTR_T", SRC_TYPE_SIMPLE},
+ {"ACPI_UPDATE_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_UUID", SRC_TYPE_STRUCT},
+ {"ACPI_VENDOR_UUID", SRC_TYPE_STRUCT},
+ {"ACPI_VENDOR_WALK_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_WALK_AML_CALLBACK", SRC_TYPE_SIMPLE},
+ {"ACPI_WALK_CALLBACK", SRC_TYPE_SIMPLE},
+ {"ACPI_WALK_RESOURCE_CALLBACK", SRC_TYPE_SIMPLE},
+ {"ACPI_WALK_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_WALK_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_WHEA_HEADER", SRC_TYPE_STRUCT},
+
+ {"ACPI_RS_LENGTH", SRC_TYPE_SIMPLE},
+ {"ACPI_RSDESC_SIZE", SRC_TYPE_SIMPLE},
+
+ {"AML_RESOURCE", SRC_TYPE_UNION},
+ {"AML_RESOURCE_ADDRESS", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_ADDRESS16", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_ADDRESS32", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_ADDRESS64", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_COMMON_SERIALBUS", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_DMA", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_END_DEPENDENT", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_END_TAG", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_EXTENDED_ADDRESS64", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_EXTENDED_IRQ", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_FIXED_DMA", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_FIXED_IO", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_FIXED_MEMORY32", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_GENERIC_REGISTER", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_GPIO", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_IO", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_I2C_SERIALBUS", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_IRQ", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_IRQ_NOFLAGS", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_LARGE_HEADER", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_MEMORY24", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_MEMORY32", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_SMALL_HEADER", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_SPI_SERIALBUS", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_START_DEPENDENT", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_START_DEPENDENT_NOPRIO", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_UART_SERIALBUS", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_VENDOR_LARGE", SRC_TYPE_STRUCT},
+ {"AML_RESOURCE_VENDOR_SMALL", SRC_TYPE_STRUCT},
+
+ {"APIC_HEADER", SRC_TYPE_STRUCT},
+ {"ARGUMENT_INFO", SRC_TYPE_STRUCT},
+ {"AE_DEBUG_REGIONS", SRC_TYPE_STRUCT},
+ {"AE_REGION", SRC_TYPE_STRUCT},
+ {"AE_TABLE_DESC", SRC_TYPE_STRUCT},
+ {"ASL_ANALYSIS_WALK_INFO", SRC_TYPE_STRUCT},
+ {"ASL_ERROR_MSG", SRC_TYPE_STRUCT},
+ {"ASL_EVENT_INFO", SRC_TYPE_STRUCT},
+ {"ASL_FILE_INFO", SRC_TYPE_STRUCT},
+ {"ASL_FILE_STATUS", SRC_TYPE_STRUCT},
+ {"ASL_INCLUDE_DIR", SRC_TYPE_STRUCT},
+ {"ASL_LISTING_NODE", SRC_TYPE_STRUCT},
+ {"ASL_MAPPING_ENTRY", SRC_TYPE_STRUCT},
+ {"ASL_METHOD_INFO", SRC_TYPE_STRUCT},
+ {"ASL_RESERVED_INFO", SRC_TYPE_STRUCT},
+ {"ASL_RESOURCE_NODE", SRC_TYPE_STRUCT},
+ {"ASL_WALK_CALLBACK", SRC_TYPE_SIMPLE},
+ {"COMMAND_INFO", SRC_TYPE_STRUCT},
+ {"UINT64_OVERLAY", SRC_TYPE_UNION},
+ {"UINT64_STRUCT", SRC_TYPE_STRUCT},
+
+ /*
+ * Acpi table definition names.
+ */
+ {"ACPI_TABLE_ASF", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_BERT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_BGRT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_BOOT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_CPEP", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_DBGP", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_DMAR", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_DRTM", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_ECDT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_EINJ", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_ERST", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_FACS", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_FADT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_FPDT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_HEST", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_HPET", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_IBFT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_IVRS", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_MADT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_MCFG", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_MCHI", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_MPST", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_MSCT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_PCCT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_RSDP", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_RSDT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_MCHI", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_S3PT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_SBST", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_SLIC", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_SLIT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_SPCR", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_SPMI", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_SRAT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_TCPA", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_UEFI", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_WAET", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_WDAT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_WDDT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_WDRT", SRC_TYPE_STRUCT},
+ {"ACPI_TABLE_XSDT", SRC_TYPE_STRUCT},
+
+ {"ACPI_ASF_ADDRESS", SRC_TYPE_STRUCT},
+ {"ACPI_ASF_ALERT", SRC_TYPE_STRUCT},
+ {"ACPI_ASF_ALERT_DATA", SRC_TYPE_STRUCT},
+ {"ACPI_ASF_CONTROL_DATA", SRC_TYPE_STRUCT},
+ {"ACPI_ASF_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_ASF_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_ASF_REMOTE", SRC_TYPE_STRUCT},
+ {"ACPI_ASF_RMCP", SRC_TYPE_STRUCT},
+ {"ACPI_BERT_REGION", SRC_TYPE_STRUCT},
+ {"ACPI_CPEP_POLLING", SRC_TYPE_STRUCT},
+ {"ACPI_DMAR_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_DMAR_DEVICE_SCOPE", SRC_TYPE_STRUCT},
+ {"ACPI_DMAR_ATSR", SRC_TYPE_STRUCT},
+ {"ACPI_DMAR_RHSA", SRC_TYPE_STRUCT},
+ {"ACPI_DMAR_HARDWARE_UNIT", SRC_TYPE_STRUCT},
+ {"ACPI_DMAR_RESERVED_MEMORY", SRC_TYPE_STRUCT},
+ {"ACPI_EINJ_ENTRY", SRC_TYPE_STRUCT},
+ {"ACPI_EINJ_TRIGGER", SRC_TYPE_STRUCT},
+ {"ACPI_FPDT_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_FPDT_BOOT", SRC_TYPE_STRUCT},
+ {"ACPI_FPDT_S3PT_PTR", SRC_TYPE_STRUCT},
+ {"ACPI_ERST_ENTRY", SRC_TYPE_STRUCT},
+ {"ACPI_ERST_INFO", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_AER_COMMON", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_NOTIFY", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_IA_ERROR_BANK", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_IA_MACHINE_CHECK", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_IA_CORRECTED", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_IA_NMI", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_AER_ROOT", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_AER", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_AER_BRIDGE", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_GENERIC", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_GENERIC_STATUS", SRC_TYPE_STRUCT},
+ {"ACPI_HEST_GENERIC_DATA", SRC_TYPE_STRUCT},
+ {"ACPI_IBFT_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_IBFT_CONTROL", SRC_TYPE_STRUCT},
+ {"ACPI_IBFT_INITIATOR", SRC_TYPE_STRUCT},
+ {"ACPI_IBFT_NIC", SRC_TYPE_STRUCT},
+ {"ACPI_IBFT_TARGET", SRC_TYPE_STRUCT},
+ {"ACPI_IVRS_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_IVRS_HARDWARE", SRC_TYPE_STRUCT},
+ {"ACPI_IVRS_DE_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_IVRS_DEVICE4", SRC_TYPE_STRUCT},
+ {"ACPI_IVRS_DEVICE8A", SRC_TYPE_STRUCT},
+ {"ACPI_IVRS_DEVICE8B", SRC_TYPE_STRUCT},
+ {"ACPI_IVRS_DEVICE8C", SRC_TYPE_STRUCT},
+ {"ACPI_IVRS_MEMORY", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_ADDRESS_OVERRIDE", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_IO_APIC", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_IO_SAPIC", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_LOCAL_APIC", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_LOCAL_APIC_NMI", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_LOCAL_APIC_OVERRIDE", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_LOCAL_SAPIC", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_LOCAL_X2APIC", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_LOCAL_X2APIC_NMI", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_GENERIC_DISTRIBUTOR", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_GENERIC_INTERRUPT", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_INTERRUPT_OVERRIDE", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_INTERRUPT_SOURCE", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_NMI_SOURCE", SRC_TYPE_STRUCT},
+ {"ACPI_MADT_PROCESSOR_APIC", SRC_TYPE_STRUCT},
+ {"ACPI_MPST_COMPONENT", SRC_TYPE_STRUCT},
+ {"ACPI_MPST_DATA_HDR", SRC_TYPE_STRUCT},
+ {"ACPI_MPST_POWER_DATA", SRC_TYPE_STRUCT},
+ {"ACPI_MPST_POWER_NODE", SRC_TYPE_STRUCT},
+ {"ACPI_MPST_POWER_STATE", SRC_TYPE_STRUCT},
+ {"ACPI_MCFG_ALLOCATION", SRC_TYPE_STRUCT},
+ {"ACPI_MSCT_PROXIMITY", SRC_TYPE_STRUCT},
+ {"ACPI_PCCT_SUBSPACE", SRC_TYPE_STRUCT},
+ {"ACPI_RSDP_COMMON", SRC_TYPE_STRUCT},
+ {"ACPI_RSDP_EXTENSION", SRC_TYPE_STRUCT},
+ {"ACPI_S3PT_RESUME", SRC_TYPE_STRUCT},
+ {"ACPI_S3PT_SUSPEND", SRC_TYPE_STRUCT},
+ {"ACPI_SLIC_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_SLIC_KEY", SRC_TYPE_STRUCT},
+ {"ACPI_SLIC_MARKER", SRC_TYPE_STRUCT},
+ {"ACPI_SRAT_CPU_AFFINITY", SRC_TYPE_STRUCT},
+ {"ACPI_SRAT_HEADER", SRC_TYPE_STRUCT},
+ {"ACPI_SRAT_MEM_AFFINITY", SRC_TYPE_STRUCT},
+ {"ACPI_SRAT_X2APIC_CPU_AFFINITY", SRC_TYPE_STRUCT},
+ {"ACPI_WDAT_ENTRY", SRC_TYPE_STRUCT},
+
+ /* Data Table compiler */
+
+ {"DT_FIELD", SRC_TYPE_STRUCT},
+ {"DT_SUBTABLE", SRC_TYPE_STRUCT},
+ {"DT_WALK_CALLBACK", SRC_TYPE_SIMPLE},
+
+ /* AcpiHelp utility */
+
+ {"AH_AML_OPCODE", SRC_TYPE_STRUCT},
+ {"AH_ASL_OPERATOR", SRC_TYPE_STRUCT},
+ {"AH_ASL_KEYWORD", SRC_TYPE_STRUCT},
+ {"AH_PREDEFINED_NAME", SRC_TYPE_STRUCT},
+
+ /* AcpiXtract utility */
+
+ {"AX_TABLE_INFO", SRC_TYPE_STRUCT},
+
+ {NULL, 0}
+};
+
+
+ACPI_IDENTIFIER_TABLE LinuxAddStruct[] = {
+ {"acpi_namespace_node"},
+ {"acpi_parse_object"},
+ {"acpi_table_desc"},
+ {"acpi_walk_state"},
+ {NULL}
+};
+
+
+ACPI_IDENTIFIER_TABLE LinuxEliminateMacros[] = {
+
+ {"ACPI_GET_ADDRESS"},
+ {"ACPI_VALID_ADDRESS"},
+ {NULL}
+};
+
+
+ACPI_IDENTIFIER_TABLE LinuxEliminateLines_C[] = {
+
+ {"#define __"},
+ {NULL}
+};
+
+
+ACPI_IDENTIFIER_TABLE LinuxEliminateLines_H[] = {
+
+ {NULL}
+};
+
+
+ACPI_IDENTIFIER_TABLE LinuxConditionalIdentifiers[] = {
+
+/* {"ACPI_USE_STANDARD_HEADERS"}, */
+ {"WIN32"},
+ {"_MSC_VER"},
+ {NULL}
+};
+
+ACPI_CONVERSION_TABLE LinuxConversionTable = {
+
+ DualLicenseHeader,
+ FLG_NO_CARRIAGE_RETURNS | FLG_LOWERCASE_DIRNAMES,
+
+ AcpiIdentifiers,
+
+ /* C source files */
+
+ LinuxDataTypes,
+ LinuxEliminateLines_C,
+ NULL,
+ LinuxEliminateMacros,
+ AcpiIdentifiers,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_CHECK_BRACES | CVT_TRIM_LINES | CVT_BRACES_ON_SAME_LINE |
+ CVT_MIXED_CASE_TO_UNDERSCORES | CVT_LOWER_CASE_IDENTIFIERS |
+ CVT_REMOVE_DEBUG_MACROS | CVT_TRIM_WHITESPACE |
+ CVT_REMOVE_EMPTY_BLOCKS | CVT_SPACES_TO_TABS8),
+
+ /* C header files */
+
+ LinuxDataTypes,
+ LinuxEliminateLines_H,
+ LinuxConditionalIdentifiers,
+ NULL,
+ AcpiIdentifiers,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_TRIM_LINES | CVT_MIXED_CASE_TO_UNDERSCORES |
+ CVT_LOWER_CASE_IDENTIFIERS | CVT_TRIM_WHITESPACE |
+ CVT_REMOVE_EMPTY_BLOCKS| CVT_REDUCE_TYPEDEFS | CVT_SPACES_TO_TABS8),
+};
+
+
+/******************************************************************************
+ *
+ * Code cleanup translation tables
+ *
+ ******************************************************************************/
+
+ACPI_CONVERSION_TABLE CleanupConversionTable = {
+
+ NULL,
+ FLG_DEFAULT_FLAGS,
+ NULL,
+ /* C source files */
+
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_CHECK_BRACES | CVT_TRIM_LINES | CVT_TRIM_WHITESPACE),
+
+ /* C header files */
+
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_TRIM_LINES | CVT_TRIM_WHITESPACE),
+};
+
+
+ACPI_CONVERSION_TABLE StatsConversionTable = {
+
+ NULL,
+ FLG_NO_FILE_OUTPUT,
+ NULL,
+
+ /* C source files */
+
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_COUNT_SHORTMULTILINE_COMMENTS),
+
+ /* C header files */
+
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_COUNT_SHORTMULTILINE_COMMENTS),
+};
+
+
+/******************************************************************************
+ *
+ * Dual License injection translation table
+ *
+ ******************************************************************************/
+
+ACPI_CONVERSION_TABLE LicenseConversionTable = {
+
+ DualLicenseHeader,
+ FLG_DEFAULT_FLAGS,
+ NULL,
+
+ /* C source files */
+
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_COUNT_SHORTMULTILINE_COMMENTS),
+
+ /* C header files */
+
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ NULL,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_COUNT_SHORTMULTILINE_COMMENTS),
+};
+
+
+/******************************************************************************
+ *
+ * Customizable translation tables
+ *
+ ******************************************************************************/
+
+ACPI_STRING_TABLE CustomReplacements[] = {
+
+
+ {"(c) 1999 - 2012", "(c) 1999 - 2012", REPLACE_WHOLE_WORD}, /* Main ACPICA source */
+ {"(c) 2006 - 2012", "(c) 2006 - 2012", REPLACE_WHOLE_WORD}, /* Test suites */
+
+#if 0
+ {"(ACPI_INTEGER)", "(UINT64)", REPLACE_WHOLE_WORD},
+ {"ACPI_INTEGER ", "UINT64 ", REPLACE_WHOLE_WORD},
+ {"ACPI_INTEGER", "UINT64", REPLACE_WHOLE_WORD},
+ {"ACPI_INTEGER_MAX", "ACPI_UINT64_MAX", REPLACE_WHOLE_WORD},
+ {"#include \"acpi.h\"", "#include \"acpi.h\"\n#include \"accommon.h\"", REPLACE_SUBSTRINGS},
+ {"AcpiTbSumTable", "AcpiTbSumTable", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_BOOT", "ACPI_SIG_BOOT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_DBGP", "ACPI_SIG_DBGP", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_DSDT", "ACPI_SIG_DSDT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_ECDT", "ACPI_SIG_ECDT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_FACS", "ACPI_SIG_FACS", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_FADT", "ACPI_SIG_FADT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_HPET", "ACPI_SIG_HPET", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_MADT", "ACPI_SIG_MADT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_MCFG", "ACPI_SIG_MCFG", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_PSDT", "ACPI_SIG_PSDT", REPLACE_WHOLE_WORD},
+ {"ACPI_NAME_RSDP", "ACPI_NAME_RSDP", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_RSDP", "ACPI_SIG_RSDP", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_RSDT", "ACPI_SIG_RSDT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_SBST", "ACPI_SIG_SBST", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_SLIT", "ACPI_SIG_SLIT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_SPCR", "ACPI_SIG_SPCR", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_SPIC", "ACPI_SIG_SPIC", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_SPMI", "ACPI_SIG_SPMI", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_SRAT", "ACPI_SIG_SRAT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_SSDT", "ACPI_SIG_SSDT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_TCPA", "ACPI_SIG_TCPA", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_WDRT", "ACPI_SIG_WDRT", REPLACE_WHOLE_WORD},
+ {"ACPI_SIG_XSDT", "ACPI_SIG_XSDT", REPLACE_WHOLE_WORD},
+
+ {"ACPI_ALLOCATE_ZEROED", "ACPI_ALLOCATE_ZEROED", REPLACE_WHOLE_WORD},
+ {"ACPI_ALLOCATE", "ACPI_ALLOCATE", REPLACE_WHOLE_WORD},
+ {"ACPI_FREE", "ACPI_FREE", REPLACE_WHOLE_WORD},
+
+ "ACPI_NATIVE_UINT", "ACPI_NATIVE_UINT", REPLACE_WHOLE_WORD,
+ "ACPI_NATIVE_UINT *", "ACPI_NATIVE_UINT *", REPLACE_WHOLE_WORD,
+ "ACPI_NATIVE_UINT", "ACPI_NATIVE_UINT", REPLACE_WHOLE_WORD,
+ "ACPI_NATIVE_INT", "ACPI_NATIVE_INT", REPLACE_WHOLE_WORD,
+ "ACPI_NATIVE_INT *", "ACPI_NATIVE_INT *", REPLACE_WHOLE_WORD,
+ "ACPI_NATIVE_INT", "ACPI_NATIVE_INT", REPLACE_WHOLE_WORD,
+#endif
+
+ {NULL, NULL, 0}
+};
+
+
+ACPI_CONVERSION_TABLE CustomConversionTable = {
+
+ NULL,
+ FLG_DEFAULT_FLAGS,
+ NULL,
+
+ /* C source files */
+
+ CustomReplacements,
+ LinuxEliminateLines_H,
+ NULL,
+ NULL,
+ NULL,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_TRIM_LINES | CVT_TRIM_WHITESPACE),
+
+ /* C header files */
+
+ CustomReplacements,
+ LinuxEliminateLines_H,
+ NULL,
+ NULL,
+ NULL,
+ (CVT_COUNT_TABS | CVT_COUNT_NON_ANSI_COMMENTS | CVT_COUNT_LINES |
+ CVT_TRIM_LINES | CVT_TRIM_WHITESPACE),
+};
+
diff --git a/source/tools/acpisrc/asutils.c b/source/tools/acpisrc/asutils.c
new file mode 100644
index 0000000000000..a596ea8cee061
--- /dev/null
+++ b/source/tools/acpisrc/asutils.c
@@ -0,0 +1,234 @@
+
+/******************************************************************************
+ *
+ * Module Name: asutils - common utilities
+ *
+ *****************************************************************************/
+
+/*
+ * 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.
+ */
+
+#include "acpisrc.h"
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsSkipUntilChar
+ *
+ * DESCRIPTION: Find the next instance of the input character
+ *
+ ******************************************************************************/
+
+char *
+AsSkipUntilChar (
+ char *Buffer,
+ char Target)
+{
+
+ while (*Buffer != Target)
+ {
+ if (!*Buffer)
+ {
+ return NULL;
+ }
+
+ Buffer++;
+ }
+
+ return (Buffer);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsSkipPastChar
+ *
+ * DESCRIPTION: Find the next instance of the input character, return a buffer
+ * pointer to this character+1.
+ *
+ ******************************************************************************/
+
+char *
+AsSkipPastChar (
+ char *Buffer,
+ char Target)
+{
+
+ while (*Buffer != Target)
+ {
+ if (!*Buffer)
+ {
+ return NULL;
+ }
+
+ Buffer++;
+ }
+
+ Buffer++;
+
+ return (Buffer);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsReplaceData
+ *
+ * DESCRIPTION: This function inserts and removes data from the file buffer.
+ * if more data is inserted than is removed, the data in the buffer
+ * is moved to make room. If less data is inserted than is removed,
+ * the remaining data is moved to close the hole.
+ *
+ ******************************************************************************/
+
+char *
+AsReplaceData (
+ char *Buffer,
+ UINT32 LengthToRemove,
+ char *BufferToAdd,
+ UINT32 LengthToAdd)
+{
+ UINT32 BufferLength;
+
+
+ /*
+ * Buffer is a string, so the length must include the terminating zero
+ */
+ BufferLength = strlen (Buffer) + 1;
+
+ if (LengthToRemove != LengthToAdd)
+ {
+ /*
+ * Move some of the existing data
+ * 1) If adding more bytes than removing, make room for the new data
+ * 2) if removing more bytes than adding, delete the extra space
+ */
+ if (LengthToRemove > 0)
+ {
+ Gbl_MadeChanges = TRUE;
+ memmove ((Buffer + LengthToAdd), (Buffer + LengthToRemove), (BufferLength - LengthToRemove));
+ }
+ }
+
+ /*
+ * Now we can move in the new data
+ */
+ if (LengthToAdd > 0)
+ {
+ Gbl_MadeChanges = TRUE;
+ memmove (Buffer, BufferToAdd, LengthToAdd);
+ }
+
+ return (Buffer + LengthToAdd);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsInsertData
+ *
+ * DESCRIPTION: This function inserts and removes data from the file buffer.
+ * if more data is inserted than is removed, the data in the buffer
+ * is moved to make room. If less data is inserted than is removed,
+ * the remaining data is moved to close the hole.
+ *
+ ******************************************************************************/
+
+char *
+AsInsertData (
+ char *Buffer,
+ char *BufferToAdd,
+ UINT32 LengthToAdd)
+{
+ UINT32 BufferLength;
+
+
+ if (LengthToAdd > 0)
+ {
+ /*
+ * Buffer is a string, so the length must include the terminating zero
+ */
+ BufferLength = strlen (Buffer) + 1;
+
+ /*
+ * Move some of the existing data
+ * 1) If adding more bytes than removing, make room for the new data
+ * 2) if removing more bytes than adding, delete the extra space
+ */
+ Gbl_MadeChanges = TRUE;
+ memmove ((Buffer + LengthToAdd), Buffer, BufferLength);
+
+ /*
+ * Now we can move in the new data
+ */
+ memmove (Buffer, BufferToAdd, LengthToAdd);
+ }
+
+ return (Buffer + LengthToAdd);
+}
+
+
+/******************************************************************************
+ *
+ * FUNCTION: AsRemoveData
+ *
+ * DESCRIPTION: This function inserts and removes data from the file buffer.
+ * if more data is inserted than is removed, the data in the buffer
+ * is moved to make room. If less data is inserted than is removed,
+ * the remaining data is moved to close the hole.
+ *
+ ******************************************************************************/
+
+char *
+AsRemoveData (
+ char *StartPointer,
+ char *EndPointer)
+{
+ UINT32 BufferLength;
+
+
+ /*
+ * Buffer is a string, so the length must include the terminating zero
+ */
+ BufferLength = strlen (EndPointer) + 1;
+
+ Gbl_MadeChanges = TRUE;
+ memmove (StartPointer, EndPointer, BufferLength);
+
+ return (StartPointer);
+}
+
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-03 00:40:50 +0000