Subversion Repositories Kolibri OS

Rev

Rev 1498 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1.  
  2. /******************************************************************************
  3.  *
  4.  * Module Name: ascase - Source conversion - lower/upper case utilities
  5.  *
  6.  *****************************************************************************/
  7.  
  8. /******************************************************************************
  9.  *
  10.  * 1. Copyright Notice
  11.  *
  12.  * Some or all of this work - Copyright (c) 1999 - 2011, Intel Corp.
  13.  * All rights reserved.
  14.  *
  15.  * 2. License
  16.  *
  17.  * 2.1. This is your license from Intel Corp. under its intellectual property
  18.  * rights.  You may have additional license terms from the party that provided
  19.  * you this software, covering your right to use that party's intellectual
  20.  * property rights.
  21.  *
  22.  * 2.2. Intel grants, free of charge, to any person ("Licensee") obtaining a
  23.  * copy of the source code appearing in this file ("Covered Code") an
  24.  * irrevocable, perpetual, worldwide license under Intel's copyrights in the
  25.  * base code distributed originally by Intel ("Original Intel Code") to copy,
  26.  * make derivatives, distribute, use and display any portion of the Covered
  27.  * Code in any form, with the right to sublicense such rights; and
  28.  *
  29.  * 2.3. Intel grants Licensee a non-exclusive and non-transferable patent
  30.  * license (with the right to sublicense), under only those claims of Intel
  31.  * patents that are infringed by the Original Intel Code, to make, use, sell,
  32.  * offer to sell, and import the Covered Code and derivative works thereof
  33.  * solely to the minimum extent necessary to exercise the above copyright
  34.  * license, and in no event shall the patent license extend to any additions
  35.  * to or modifications of the Original Intel Code.  No other license or right
  36.  * is granted directly or by implication, estoppel or otherwise;
  37.  *
  38.  * The above copyright and patent license is granted only if the following
  39.  * conditions are met:
  40.  *
  41.  * 3. Conditions
  42.  *
  43.  * 3.1. Redistribution of Source with Rights to Further Distribute Source.
  44.  * Redistribution of source code of any substantial portion of the Covered
  45.  * Code or modification with rights to further distribute source must include
  46.  * the above Copyright Notice, the above License, this list of Conditions,
  47.  * and the following Disclaimer and Export Compliance provision.  In addition,
  48.  * Licensee must cause all Covered Code to which Licensee contributes to
  49.  * contain a file documenting the changes Licensee made to create that Covered
  50.  * Code and the date of any change.  Licensee must include in that file the
  51.  * documentation of any changes made by any predecessor Licensee.  Licensee
  52.  * must include a prominent statement that the modification is derived,
  53.  * directly or indirectly, from Original Intel Code.
  54.  *
  55.  * 3.2. Redistribution of Source with no Rights to Further Distribute Source.
  56.  * Redistribution of source code of any substantial portion of the Covered
  57.  * Code or modification without rights to further distribute source must
  58.  * include the following Disclaimer and Export Compliance provision in the
  59.  * documentation and/or other materials provided with distribution.  In
  60.  * addition, Licensee may not authorize further sublicense of source of any
  61.  * portion of the Covered Code, and must include terms to the effect that the
  62.  * license from Licensee to its licensee is limited to the intellectual
  63.  * property embodied in the software Licensee provides to its licensee, and
  64.  * not to intellectual property embodied in modifications its licensee may
  65.  * make.
  66.  *
  67.  * 3.3. Redistribution of Executable. Redistribution in executable form of any
  68.  * substantial portion of the Covered Code or modification must reproduce the
  69.  * above Copyright Notice, and the following Disclaimer and Export Compliance
  70.  * provision in the documentation and/or other materials provided with the
  71.  * distribution.
  72.  *
  73.  * 3.4. Intel retains all right, title, and interest in and to the Original
  74.  * Intel Code.
  75.  *
  76.  * 3.5. Neither the name Intel nor any other trademark owned or controlled by
  77.  * Intel shall be used in advertising or otherwise to promote the sale, use or
  78.  * other dealings in products derived from or relating to the Covered Code
  79.  * without prior written authorization from Intel.
  80.  *
  81.  * 4. Disclaimer and Export Compliance
  82.  *
  83.  * 4.1. INTEL MAKES NO WARRANTY OF ANY KIND REGARDING ANY SOFTWARE PROVIDED
  84.  * HERE.  ANY SOFTWARE ORIGINATING FROM INTEL OR DERIVED FROM INTEL SOFTWARE
  85.  * IS PROVIDED "AS IS," AND INTEL WILL NOT PROVIDE ANY SUPPORT,  ASSISTANCE,
  86.  * INSTALLATION, TRAINING OR OTHER SERVICES.  INTEL WILL NOT PROVIDE ANY
  87.  * UPDATES, ENHANCEMENTS OR EXTENSIONS.  INTEL SPECIFICALLY DISCLAIMS ANY
  88.  * IMPLIED WARRANTIES OF MERCHANTABILITY, NONINFRINGEMENT AND FITNESS FOR A
  89.  * PARTICULAR PURPOSE.
  90.  *
  91.  * 4.2. IN NO EVENT SHALL INTEL HAVE ANY LIABILITY TO LICENSEE, ITS LICENSEES
  92.  * OR ANY OTHER THIRD PARTY, FOR ANY LOST PROFITS, LOST DATA, LOSS OF USE OR
  93.  * COSTS OF PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, OR FOR ANY INDIRECT,
  94.  * SPECIAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THIS AGREEMENT, UNDER ANY
  95.  * CAUSE OF ACTION OR THEORY OF LIABILITY, AND IRRESPECTIVE OF WHETHER INTEL
  96.  * HAS ADVANCE NOTICE OF THE POSSIBILITY OF SUCH DAMAGES.  THESE LIMITATIONS
  97.  * SHALL APPLY NOTWITHSTANDING THE FAILURE OF THE ESSENTIAL PURPOSE OF ANY
  98.  * LIMITED REMEDY.
  99.  *
  100.  * 4.3. Licensee shall not export, either directly or indirectly, any of this
  101.  * software or system incorporating such software without first obtaining any
  102.  * required license or other approval from the U. S. Department of Commerce or
  103.  * any other agency or department of the United States Government.  In the
  104.  * event Licensee exports any such software from the United States or
  105.  * re-exports any such software from a foreign destination, Licensee shall
  106.  * ensure that the distribution and export/re-export of the software is in
  107.  * compliance with all laws, regulations, orders, or other restrictions of the
  108.  * U.S. Export Administration Regulations. Licensee agrees that neither it nor
  109.  * any of its subsidiaries will export/re-export any technical data, process,
  110.  * software, or service, directly or indirectly, to any country for which the
  111.  * United States government or any agency thereof requires an export license,
  112.  * other governmental approval, or letter of assurance, without first obtaining
  113.  * such license, approval or letter.
  114.  *
  115.  *****************************************************************************/
  116.  
  117. #include "acpisrc.h"
  118.  
  119. /* Local prototypes */
  120.  
  121. void
  122. AsUppercaseTokens (
  123.     char                    *Buffer,
  124.     char                    *PrefixString);
  125.  
  126.  
  127. /******************************************************************************
  128.  *
  129.  * FUNCTION:    AsLowerCaseString
  130.  *
  131.  * DESCRIPTION: LowerCase all instances of a target string with a replacement
  132.  *              string.  Returns count of the strings replaced.
  133.  *
  134.  ******************************************************************************/
  135.  
  136. int
  137. AsLowerCaseString (
  138.     char                    *Target,
  139.     char                    *Buffer)
  140. {
  141.     char                    *SubString1;
  142.     char                    *SubString2;
  143.     char                    *SubBuffer;
  144.     int                     TargetLength;
  145.     int                     LowerCaseCount = 0;
  146.     int                     i;
  147.  
  148.  
  149.     TargetLength = strlen (Target);
  150.  
  151.     SubBuffer = Buffer;
  152.     SubString1 = Buffer;
  153.  
  154.     while (SubString1)
  155.     {
  156.         /* Find the target string */
  157.  
  158.         SubString1 = strstr (SubBuffer, Target);
  159.         if (!SubString1)
  160.         {
  161.             return LowerCaseCount;
  162.         }
  163.  
  164.         /*
  165.          * Check for translation escape string -- means to ignore
  166.          * blocks of code while replacing
  167.          */
  168.         SubString2 = strstr (SubBuffer, AS_START_IGNORE);
  169.  
  170.         if ((SubString2) &&
  171.             (SubString2 < SubString1))
  172.         {
  173.             /* Find end of the escape block starting at "Substring2" */
  174.  
  175.             SubString2 = strstr (SubString2, AS_STOP_IGNORE);
  176.             if (!SubString2)
  177.             {
  178.                 /* Didn't find terminator */
  179.  
  180.                 return LowerCaseCount;
  181.             }
  182.  
  183.             /* Move buffer to end of escape block and continue */
  184.  
  185.             SubBuffer = SubString2;
  186.         }
  187.  
  188.         /* Do the actual replace if the target was found */
  189.  
  190.         else
  191.         {
  192.             if (!AsMatchExactWord (SubString1, TargetLength))
  193.             {
  194.                 SubBuffer = SubString1 + 1;
  195.                 continue;
  196.             }
  197.  
  198.             for (i = 0; i < TargetLength; i++)
  199.             {
  200.                 SubString1[i] = (char) tolower ((int) SubString1[i]);
  201.             }
  202.  
  203.             SubBuffer = SubString1 + TargetLength;
  204.  
  205.             if ((Gbl_WidenDeclarations) && (!Gbl_StructDefs))
  206.             {
  207.                 if ((SubBuffer[0] == ' ') && (SubBuffer[1] == ' '))
  208.                 {
  209.                     AsInsertData (SubBuffer, "        ", 8);
  210.                 }
  211.             }
  212.  
  213.             LowerCaseCount++;
  214.         }
  215.     }
  216.  
  217.     return LowerCaseCount;
  218. }
  219.  
  220.  
  221. /******************************************************************************
  222.  *
  223.  * FUNCTION:    AsMixedCaseToUnderscores
  224.  *
  225.  * DESCRIPTION: Converts mixed case identifiers to underscored identifiers.
  226.  *              for example,
  227.  *
  228.  *              ThisUsefullyNamedIdentifier   becomes:
  229.  *
  230.  *              this_usefully_named_identifier
  231.  *
  232.  ******************************************************************************/
  233.  
  234. void
  235. AsMixedCaseToUnderscores (
  236.     char                    *Buffer)
  237. {
  238.     UINT32                  Length;
  239.     char                    *SubBuffer = Buffer;
  240.     char                    *TokenEnd;
  241.     char                    *TokenStart = NULL;
  242.     char                    *SubString;
  243.     BOOLEAN                 HasLowerCase = FALSE;
  244.  
  245.  
  246.     while (*SubBuffer)
  247.     {
  248.         /* Ignore whitespace */
  249.  
  250.         if (*SubBuffer == ' ')
  251.         {
  252.             while (*SubBuffer == ' ')
  253.             {
  254.                 SubBuffer++;
  255.             }
  256.             TokenStart = NULL;
  257.             HasLowerCase = FALSE;
  258.             continue;
  259.         }
  260.  
  261.         /* Ignore commas */
  262.  
  263.         if ((*SubBuffer == ',') ||
  264.             (*SubBuffer == '>') ||
  265.             (*SubBuffer == ')'))
  266.         {
  267.             SubBuffer++;
  268.             TokenStart = NULL;
  269.             HasLowerCase = FALSE;
  270.             continue;
  271.         }
  272.  
  273.         /* Check for quoted string -- ignore */
  274.  
  275.         if (*SubBuffer == '"')
  276.         {
  277.             SubBuffer++;
  278.             while (*SubBuffer != '"')
  279.             {
  280.                 if (!*SubBuffer)
  281.                 {
  282.                     return;
  283.                 }
  284.  
  285.                 /* Handle embedded escape sequences */
  286.  
  287.                 if (*SubBuffer == '\\')
  288.                 {
  289.                     SubBuffer++;
  290.                 }
  291.                 SubBuffer++;
  292.             }
  293.             SubBuffer++;
  294.             continue;
  295.         }
  296.  
  297.         if (islower ((int) *SubBuffer))
  298.         {
  299.             HasLowerCase = TRUE;
  300.         }
  301.  
  302.         /*
  303.          * Check for translation escape string -- means to ignore
  304.          * blocks of code while replacing
  305.          */
  306.         if ((SubBuffer[0] == '/') &&
  307.             (SubBuffer[1] == '*') &&
  308.             (SubBuffer[2] == '!'))
  309.         {
  310.             SubBuffer = strstr (SubBuffer, "!*/");
  311.             if (!SubBuffer)
  312.             {
  313.                 return;
  314.             }
  315.             continue;
  316.         }
  317.  
  318.         /* Ignore hex constants */
  319.  
  320.         if (SubBuffer[0] == '0')
  321.         {
  322.             if ((SubBuffer[1] == 'x') ||
  323.                 (SubBuffer[1] == 'X'))
  324.             {
  325.                 SubBuffer += 2;
  326.                 while (isxdigit ((int) *SubBuffer))
  327.                 {
  328.                     SubBuffer++;
  329.                 }
  330.                 continue;
  331.             }
  332.         }
  333.  
  334. /* OBSOLETE CODE, all quoted strings now completely ignored. */
  335. #if 0
  336.         /* Ignore format specification fields */
  337.  
  338.         if (SubBuffer[0] == '%')
  339.         {
  340.             SubBuffer++;
  341.  
  342.             while ((isalnum (*SubBuffer)) || (*SubBuffer == '.'))
  343.             {
  344.                 SubBuffer++;
  345.             }
  346.  
  347.             continue;
  348.         }
  349. #endif
  350.  
  351.         /* Ignore standard escape sequences (\n, \r, etc.)  Not Hex or Octal escapes */
  352.  
  353.         if (SubBuffer[0] == '\\')
  354.         {
  355.             SubBuffer += 2;
  356.             continue;
  357.         }
  358.  
  359.         /*
  360.          * Ignore identifiers that already contain embedded underscores
  361.          * These are typically C macros or defines (all upper case)
  362.          * Note: there are some cases where identifiers have underscores
  363.          * AcpiGbl_* for example. HasLowerCase flag handles these.
  364.          */
  365.         if ((*SubBuffer == '_') && (!HasLowerCase) && (TokenStart))
  366.         {
  367.             /* Check the rest of the identifier for any lower case letters */
  368.  
  369.             SubString = SubBuffer;
  370.             while ((isalnum ((int) *SubString)) || (*SubString == '_'))
  371.             {
  372.                 if (islower ((int) *SubString))
  373.                 {
  374.                     HasLowerCase = TRUE;
  375.                 }
  376.                 SubString++;
  377.             }
  378.  
  379.             /* If no lower case letters, we can safely ignore the entire token */
  380.  
  381.             if (!HasLowerCase)
  382.             {
  383.                 SubBuffer = SubString;
  384.                 continue;
  385.             }
  386.         }
  387.  
  388.         /* A capital letter may indicate the start of a token; save it */
  389.  
  390.         if (isupper ((int) SubBuffer[0]))
  391.         {
  392.             TokenStart = SubBuffer;
  393.         }
  394.  
  395.         /*
  396.          * Convert each pair of letters that matches the form:
  397.          *
  398.          *      <LowerCase><UpperCase>
  399.          * to
  400.          *      <LowerCase><Underscore><LowerCase>
  401.          */
  402.         else if ((islower ((int) SubBuffer[0]) || isdigit ((int) SubBuffer[0])) &&
  403.                  (isupper ((int) SubBuffer[1])))
  404.         {
  405.             if (isdigit ((int) SubBuffer[0]))
  406.             {
  407.                 /* Ignore <UpperCase><Digit><UpperCase> */
  408.                 /* Ignore <Underscore><Digit><UpperCase> */
  409.  
  410.                 if (isupper ((int) *(SubBuffer-1)) ||
  411.                     *(SubBuffer-1) == '_')
  412.                 {
  413.                     SubBuffer++;
  414.                     continue;
  415.                 }
  416.             }
  417.  
  418.             /*
  419.              * Matched the pattern.
  420.              * Find the end of this identifier (token)
  421.              */
  422.             TokenEnd = SubBuffer;
  423.             while ((isalnum ((int) *TokenEnd)) || (*TokenEnd == '_'))
  424.             {
  425.                 TokenEnd++;
  426.             }
  427.  
  428.             /* Force the UpperCase letter (#2) to lower case */
  429.  
  430.             Gbl_MadeChanges = TRUE;
  431.             SubBuffer[1] = (char) tolower ((int) SubBuffer[1]);
  432.  
  433.             SubString = TokenEnd;
  434.             Length = 0;
  435.  
  436.             while (*SubString != '\n')
  437.             {
  438.                 /*
  439.                  * If we have at least two trailing spaces, we can get rid of
  440.                  * one to make up for the newly inserted underscore.  This will
  441.                  * help preserve the alignment of the text
  442.                  */
  443.                 if ((SubString[0] == ' ') &&
  444.                     (SubString[1] == ' '))
  445.                 {
  446.                     Length = SubString - SubBuffer - 2;
  447.                     break;
  448.                 }
  449.  
  450.                 SubString++;
  451.             }
  452.  
  453.             if (!Length)
  454.             {
  455.                 Length = strlen (&SubBuffer[1]);
  456.             }
  457.  
  458.             memmove (&SubBuffer[2], &SubBuffer[1], Length + 1);
  459.             SubBuffer[1] = '_';
  460.             SubBuffer +=2;
  461.  
  462.             /* Lower case the leading character of the token */
  463.  
  464.             if (TokenStart)
  465.             {
  466.                 *TokenStart = (char) tolower ((int) *TokenStart);
  467.                 TokenStart = NULL;
  468.             }
  469.         }
  470.  
  471.         SubBuffer++;
  472.     }
  473. }
  474.  
  475.  
  476. /******************************************************************************
  477.  *
  478.  * FUNCTION:    AsLowerCaseIdentifiers
  479.  *
  480.  * DESCRIPTION: Converts mixed case identifiers to lower case.  Leaves comments,
  481.  *              quoted strings, and all-upper-case macros alone.
  482.  *
  483.  ******************************************************************************/
  484.  
  485. void
  486. AsLowerCaseIdentifiers (
  487.     char                    *Buffer)
  488. {
  489.     char                    *SubBuffer = Buffer;
  490.  
  491.  
  492.     while (*SubBuffer)
  493.     {
  494.         /*
  495.          * Check for translation escape string -- means to ignore
  496.          * blocks of code while replacing
  497.          */
  498.         if ((SubBuffer[0] == '/') &&
  499.             (SubBuffer[1] == '*') &&
  500.             (SubBuffer[2] == '!'))
  501.         {
  502.             SubBuffer = strstr (SubBuffer, "!*/");
  503.             if (!SubBuffer)
  504.             {
  505.                 return;
  506.             }
  507.         }
  508.  
  509.         /* Ignore comments */
  510.  
  511.         if ((SubBuffer[0] == '/') &&
  512.             (SubBuffer[1] == '*'))
  513.         {
  514.             SubBuffer = strstr (SubBuffer, "*/");
  515.             if (!SubBuffer)
  516.             {
  517.                 return;
  518.             }
  519.  
  520.             SubBuffer += 2;
  521.         }
  522.  
  523.         /* Ignore quoted strings */
  524.  
  525.         if ((SubBuffer[0] == '\"') && (SubBuffer[1] != '\''))
  526.         {
  527.             SubBuffer++;
  528.  
  529.             /* Find the closing quote */
  530.  
  531.             while (SubBuffer[0])
  532.             {
  533.                 /* Ignore escaped quote characters */
  534.  
  535.                 if (SubBuffer[0] == '\\')
  536.                 {
  537.                     SubBuffer++;
  538.                 }
  539.                 else if (SubBuffer[0] == '\"')
  540.                 {
  541.                     SubBuffer++;
  542.                     break;
  543.                 }
  544.                 SubBuffer++;
  545.             }
  546.         }
  547.  
  548.         if (!SubBuffer[0])
  549.         {
  550.             return;
  551.         }
  552.  
  553.         /*
  554.          * Only lower case if we have an upper followed by a lower
  555.          * This leaves the all-uppercase things (macros, etc.) intact
  556.          */
  557.         if ((isupper ((int) SubBuffer[0])) &&
  558.             (islower ((int) SubBuffer[1])))
  559.         {
  560.             Gbl_MadeChanges = TRUE;
  561.             *SubBuffer = (char) tolower ((int) *SubBuffer);
  562.         }
  563.  
  564.         SubBuffer++;
  565.     }
  566. }
  567.  
  568.  
  569. /******************************************************************************
  570.  *
  571.  * FUNCTION:    AsUppercaseTokens
  572.  *
  573.  * DESCRIPTION: Force to uppercase all tokens that begin with the prefix string.
  574.  *              used to convert mixed-case macros and constants to uppercase.
  575.  *
  576.  ******************************************************************************/
  577.  
  578. void
  579. AsUppercaseTokens (
  580.     char                    *Buffer,
  581.     char                    *PrefixString)
  582. {
  583.     char                    *SubBuffer;
  584.     char                    *TokenEnd;
  585.     char                    *SubString;
  586.     int                     i;
  587.     UINT32                  Length;
  588.  
  589.  
  590.     SubBuffer = Buffer;
  591.  
  592.     while (SubBuffer)
  593.     {
  594.         SubBuffer = strstr (SubBuffer, PrefixString);
  595.         if (SubBuffer)
  596.         {
  597.             TokenEnd = SubBuffer;
  598.             while ((isalnum ((int) *TokenEnd)) || (*TokenEnd == '_'))
  599.             {
  600.                 TokenEnd++;
  601.             }
  602.  
  603.             for (i = 0; i < (TokenEnd - SubBuffer); i++)
  604.             {
  605.                 if ((islower ((int) SubBuffer[i])) &&
  606.                     (isupper ((int) SubBuffer[i+1])))
  607.                 {
  608.  
  609.                     SubString = TokenEnd;
  610.                     Length = 0;
  611.  
  612.                     while (*SubString != '\n')
  613.                     {
  614.                         if ((SubString[0] == ' ') &&
  615.                             (SubString[1] == ' '))
  616.                         {
  617.                             Length = SubString - &SubBuffer[i] - 2;
  618.                             break;
  619.                         }
  620.  
  621.                         SubString++;
  622.                     }
  623.  
  624.                     if (!Length)
  625.                     {
  626.                         Length = strlen (&SubBuffer[i+1]);
  627.                     }
  628.  
  629.                     memmove (&SubBuffer[i+2], &SubBuffer[i+1], (Length+1));
  630.                     SubBuffer[i+1] = '_';
  631.                     i +=2;
  632.                     TokenEnd++;
  633.                 }
  634.             }
  635.  
  636.             for (i = 0; i < (TokenEnd - SubBuffer); i++)
  637.             {
  638.                 SubBuffer[i] = (char) toupper ((int) SubBuffer[i]);
  639.             }
  640.  
  641.             SubBuffer = TokenEnd;
  642.         }
  643.     }
  644. }
  645.  
  646.  
  647.