--- /dev/null	jeu. déc. 26 13:50:12 2013
+++ new/usr/src/common/acpica/tools/acpisrc/ascase.c	jeu. déc. 26 13:50:12 2013
@@ -0,0 +1,638 @@
+/******************************************************************************
+ *
+ * Module Name: ascase - Source conversion - lower/upper case utilities
+ *
+ *****************************************************************************/
+
+/*
+ * Copyright (C) 2000 - 2013, 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
+         */
+        if (Gbl_IgnoreTranslationEscapes)
+        {
+            SubString2 = NULL;
+        }
+        else
+        {
+            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,
+    char                    *Filename)
+{
+    UINT32                  Length;
+    char                    *SubBuffer = Buffer;
+    char                    *TokenEnd;
+    char                    *TokenStart = NULL;
+    char                    *SubString;
+    UINT32                  LineNumber = 1;
+    UINT32                  Count;
+
+
+    /*
+     * Examine the entire buffer (contains the entire file)
+     * We are only interested in these tokens:
+     *      Escape sequences - ignore entire sequence
+     *      Single-quoted constants - ignore
+     *      Quoted strings - ignore entire string
+     *      Translation escape - starts with /,*,!
+     *      Decimal and hex numeric constants - ignore entire token
+     *      Entire uppercase token - ignore, it is a macro or define
+     *      Starts with underscore, then a lowercase or digit: convert
+     */
+    while (*SubBuffer)
+    {
+        if (*SubBuffer == '\n')
+        {
+            LineNumber++;
+            SubBuffer++;
+            continue;
+        }
+
+        /* Ignore standard escape sequences (\n, \r, etc.)  Not Hex or Octal escapes */
+
+        if (*SubBuffer == '\\')
+        {
+            SubBuffer += 2;
+            continue;
+        }
+
+        /* Ignore single-quoted characters */
+
+        if (*SubBuffer == '\'')
+        {
+            SubBuffer += 3;
+            continue;
+        }
+
+        /* Ignore standard double-quoted strings */
+
+        if (*SubBuffer == '"')
+        {
+            SubBuffer++;
+            Count = 0;
+            while (*SubBuffer != '"')
+            {
+                Count++;
+                if ((!*SubBuffer) ||
+                     (Count > 8192))
+                {
+                    printf ("Found an unterminated quoted string!, line %u: %s\n",
+                        LineNumber, Filename);
+                    return;
+                }
+
+                /* Handle escape sequences */
+
+                if (*SubBuffer == '\\')
+                {
+                    SubBuffer++;
+                }
+
+                SubBuffer++;
+            }
+            SubBuffer++;
+            continue;
+        }
+
+        /*
+         * Check for translation escape string. It means to ignore
+         * blocks of code during this code conversion.
+         */
+        if ((SubBuffer[0] == '/') &&
+            (SubBuffer[1] == '*') &&
+            (SubBuffer[2] == '!'))
+        {
+            SubBuffer = strstr (SubBuffer, "!*/");
+            if (!SubBuffer)
+            {
+                printf ("Found an unterminated translation escape!, line %u: %s\n",
+                    LineNumber, Filename);
+                return;
+            }
+            continue;
+        }
+
+        /* Ignore anything that starts with a number (0-9) */
+
+        if (isdigit ((int) *SubBuffer))
+        {
+            /* Ignore hex constants */
+
+            if ((SubBuffer[0] == '0') &&
+               ((SubBuffer[1] == 'x') || (SubBuffer[1] == 'X')))
+            {
+                SubBuffer += 2;
+            }
+
+            /* Skip over all digits, both decimal and hex */
+
+            while (isxdigit ((int) *SubBuffer))
+            {
+                SubBuffer++;
+            }
+            TokenStart = NULL;
+            continue;
+        }
+
+        /*
+         * Check for fully upper case identifiers. These are usually macros
+         * or defines. Allow decimal digits and embedded underscores.
+         */
+        if (isupper ((int) *SubBuffer))
+        {
+            SubString = SubBuffer + 1;
+            while ((isupper ((int) *SubString)) ||
+                   (isdigit ((int) *SubString)) ||
+                   (*SubString == '_'))
+            {
+                SubString++;
+            }
+
+            /*
+             * For the next character, anything other than a lower case
+             * means that the identifier has terminated, and contains
+             * exclusively Uppers/Digits/Underscores. Ignore the entire
+             * identifier.
+             */
+            if (!islower ((int) *SubString))
+            {
+                SubBuffer = SubString + 1;
+                continue;
+            }
+        }
+
+        /*
+         * These forms may indicate an identifier that can be converted:
+         *      <UpperCase><LowerCase> (Ax)
+         *      <UpperCase><Number> (An)
+         */
+        if (isupper ((int) SubBuffer[0]) &&
+          ((islower ((int) SubBuffer[1])) || isdigit ((int) SubBuffer[1])))
+        {
+            TokenStart = SubBuffer;
+            SubBuffer++;
+
+            while (1)
+            {
+                /* Walk over the lower case letters and decimal digits */
+
+                while (islower ((int) *SubBuffer) ||
+                       isdigit ((int) *SubBuffer))
+                {
+                    SubBuffer++;
+                }
+
+                /* Check for end of line or end of token */
+
+                if (*SubBuffer == '\n')
+                {
+                    LineNumber++;
+                    break;
+                }
+
+                if (*SubBuffer == ' ')
+                {
+                    /* Check for form "Axx - " in a parameter header description */
+
+                    while (*SubBuffer == ' ')
+                    {
+                        SubBuffer++;
+                    }
+
+                    SubBuffer--;
+                    if ((SubBuffer[1] == '-') &&
+                        (SubBuffer[2] == ' '))
+                    {
+                        if (TokenStart)
+                        {
+                            *TokenStart = (char) tolower ((int) *TokenStart);
+                        }
+                    }
+                    break;
+                }
+
+                /*
+                 * Ignore these combinations:
+                 *      <Letter><Digit><UpperCase>
+                 *      <Digit><Digit><UpperCase>
+                 *      <Underscore><Digit><UpperCase>
+                 */
+                if (isdigit ((int) *SubBuffer))
+                {
+                    if (isalnum ((int) *(SubBuffer-1)) ||
+                        *(SubBuffer-1) == '_')
+                    {
+                        break;
+                    }
+                }
+
+                /* Ignore token if next character is not uppercase or digit */
+
+                if (!isupper ((int) *SubBuffer) &&
+                    !isdigit ((int) *SubBuffer))
+                {
+                    break;
+                }
+
+                /*
+                 * Form <UpperCase><LowerCaseLetters><UpperCase> (AxxB):
+                 * Convert leading character of the token to lower case
+                 */
+                if (TokenStart)
+                {
+                    *TokenStart = (char) tolower ((int) *TokenStart);
+                    TokenStart = NULL;
+                }
+
+                /* Find the end of this identifier (token) */
+
+                TokenEnd = SubBuffer - 1;
+                while ((isalnum ((int) *TokenEnd)) ||
+                       (*TokenEnd == '_'))
+                {
+                    TokenEnd++;
+                }
+
+                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 - 1;
+                        break;
+                    }
+
+                    SubString++;
+                }
+
+                if (!Length)
+                {
+                    Length = strlen (&SubBuffer[0]);
+                }
+
+                /*
+                 * Within this identifier, convert this pair of letters that
+                 * matches the form:
+                 *
+                 *      <LowerCase><UpperCase>
+                 * to
+                 *      <LowerCase><Underscore><LowerCase>
+                 */
+                Gbl_MadeChanges = TRUE;
+
+                /* Insert the underscore */
+
+                memmove (&SubBuffer[1], &SubBuffer[0], Length + 1);
+                SubBuffer[0] = '_';
+
+                /*
+                 * If we have <UpperCase><UpperCase>, leave them as-is
+                 * Enables transforms like:
+                 *      LocalFADT -> local_FADT
+                 */
+                if (isupper ((int) SubBuffer[2]))
+                {
+                    SubBuffer += 1;
+                    break;
+                }
+
+                /* Lower case the original upper case letter */
+
+                SubBuffer[1] = (char) tolower ((int) SubBuffer[1]);
+                SubBuffer += 2;
+            }
+        }
+
+        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;
+        }
+    }
+}
