Changeset 3730 for trunk/src/kernel32/heapstring.cpp

Timestamp:

Jun 18, 2000, 2:55:17 PM (25 years ago)

Author:

phaller

Message:

Fix: GetNumberFormat, memory leak

File:

• trunk/src/kernel32/heapstring.cpp (modified) (6 diffs)

trunk/src/kernel32/heapstring.cpp

@@ -1 @@
-/* $Id: heapstring.cpp,v 1.27 2000-06-12 12:20:05 phaller Exp $ */
+/* $Id: heapstring.cpp,v 1.28 2000-06-18 12:55:17 phaller Exp $ */
 
 /*
@@ -20 +20 @@
 #include <stdlib.h>
 #include <string.h>
+#include <stdio.h>
 #include <winnls.h>
 #include <unicode.h>
@@ -1052 +1053 @@
 
 
+
+/**************************************************************************
+ *           This function is used just locally !
+ *  Description: Inverts a string.
+ */ 
+static void OLE_InvertString(char* string)
+{    
+    char    sTmpArray[128];
+    INT     counter, i = 0;
+
+    for (counter = strlen(string); counter > 0; counter--)
+    {
+        memcpy(sTmpArray + i, string + counter-1, 1);
+        i++;
+    }
+    memcpy(sTmpArray + i, "\0", 1);
+    strcpy(string, sTmpArray);
+}
+
+/***************************************************************************************
+ *           This function is used just locally !
+ *  Description: Test if the given string (psNumber) is valid or not.
+ *               The valid characters are the following:
+ *               - Characters '0' through '9'. 
+ *               - One decimal point (dot) if the number is a floating-point value. 
+ *               - A minus sign in the first character position if the number is 
+ *                 a negative value.
+ *              If the function succeeds, psBefore/psAfter will point to the string
+ *              on the right/left of the decimal symbol. pbNegative indicates if the 
+ *              number is negative.
+ */
+static INT OLE_GetNumberComponents(char* pInput, char* psBefore, char* psAfter, BOOL* pbNegative)
+{
+char    sNumberSet[] = "0123456789";
+BOOL    bInDecimal = FALSE;
+
+        /* Test if we do have a minus sign */
+        if ( *pInput == '-' )
+        {
+                *pbNegative = TRUE;
+                pInput++; /* Jump to the next character. */
+        }
+        
+        while(*pInput != '\0')
+        {
+                /* Do we have a valid numeric character */
+                if ( strchr(sNumberSet, *pInput) != NULL )
+                {
+                        if (bInDecimal == TRUE)
+                *psAfter++ = *pInput;
+                        else
+                *psBefore++ = *pInput;
+                }
+                else
+                {
+                        /* Is this a decimal point (dot) */
+                        if ( *pInput == '.' )
+                        {
+                                /* Is it the first time we find it */
+                                if ((bInDecimal == FALSE))
+                                        bInDecimal = TRUE;
+                                else
+                                        return -1; /* ERROR: Invalid parameter */
+                        }
+                        else
+                        {
+                                /* It's neither a numeric character, nor a decimal point.
+                                 * Thus, return an error.
+                 */
+                                return -1;
+                        }
+                }
+        pInput++;
+        }
+        
+        /* Add an End of Line character to the output buffers */
+        *psBefore = '\0';
+        *psAfter = '\0';
+
+        return 0; 
+}
+
+/**************************************************************************
+ *           This function is used just locally !
+ *  Description: A number could be formatted using different numbers 
+ *               of "digits in group" (example: 4;3;2;0).
+ *               The first parameter of this function is an array
+ *               containing the rule to be used. It's format is the following:
+ *               |NDG|DG1|DG2|...|0|
+ *               where NDG is the number of used "digits in group" and DG1, DG2,
+ *               are the corresponding "digits in group".
+ *               Thus, this function returns the grouping value in the array
+ *               pointed by the second parameter.
+ */
+static INT OLE_GetGrouping(char* sRule, INT index)
+{
+    char    sData[2], sRuleSize[2];
+    INT     nData, nRuleSize;
+
+    memcpy(sRuleSize, sRule, 1);
+    memcpy(sRuleSize+1, "\0", 1);
+    nRuleSize = atoi(sRuleSize);
+
+    if (index > 0 && index < nRuleSize)
+    {
+        memcpy(sData, sRule+index, 1);
+        memcpy(sData+1, "\0", 1);
+        nData = atoi(sData);            
+    }
+        
+    else
+    {
+        memcpy(sData, sRule+nRuleSize-1, 1);
+        memcpy(sData+1, "\0", 1);
+        nData = atoi(sData);            
+    }
+    
+    return nData;
+}
+
+
 /*****************************************************************************
  * Name      : GetNumberFormat
@@ -1058 +1180 @@
  * Variables :
  * Result    :
- * Remark    :
+ * Remark    : KERNEL32.355
  * Status    :
  *
@@ -1065 +1187 @@
 
 
-ODINFUNCTION6(int,               GetNumberFormatA,
-              LCID,              Locale,
-              DWORD,             dwFlags,
-              LPCSTR,            lpValue,
+ODINFUNCTION6(INT,               GetNumberFormatA,
+              LCID,              locale,
+              DWORD,             dwflags,
+              LPCSTR,            lpvalue,
               CONST NUMBERFMTA *,lpFormat,
               LPSTR,             lpNumberStr,
               int,               cchNumber)
 {
-  dprintf(("GetNumberFormatA(%08x,%08x,%s,%08x,%s,%08x) not properly implemented.\n",
-           Locale,
-           dwFlags,
-           lpValue,
-           lpFormat,
-           lpNumberStr,
-           cchNumber));
+  dprintf(("not properly implemented.\n"));
   
-  // @@@PH cheap ass emulation
-  lstrcpynA(lpNumberStr,
-            lpValue,
-            cchNumber);
-  
-  return lstrlenA(lpNumberStr);
-}
+  char   sNumberDigits[3], sDecimalSymbol[5], sDigitsInGroup[11], sDigitGroupSymbol[5], sILZero[2];
+  INT    nNumberDigits, nNumberDecimal, i, j, nCounter, nStep, nRuleIndex, nGrouping, nDigits, retVal, nLZ;
+  char   sNumber[128], sDestination[128], sDigitsAfterDecimal[10], sDigitsBeforeDecimal[128];
+  char   sRule[10], sSemiColumn[]=";", sBuffer[5], sNegNumber[2];
+  char   *pStr = NULL, *pTmpStr = NULL;
+  LCID   systemDefaultLCID;
+  BOOL   bNegative = FALSE;
+  enum   Operations
+  {
+    USE_PARAMETER,
+    USE_LOCALEINFO,
+    USE_SYSTEMDEFAULT,
+    RETURN_ERROR
+  } used_operation;
+
+  strncpy(sNumber, lpvalue, 128);
+  sNumber[127] = '\0';
+
+  /* Make sure we have a valid input string, get the number
+   * of digits before and after the decimal symbol, and check
+   * if this is a negative number.
+   */
+  if ( OLE_GetNumberComponents(sNumber, sDigitsBeforeDecimal, sDigitsAfterDecimal, &bNegative) != -1)
+  {
+    nNumberDecimal = strlen(sDigitsBeforeDecimal);
+    nDigits = strlen(sDigitsAfterDecimal);
+  }
+  else
+  {
+    SetLastError(ERROR_INVALID_PARAMETER);
+    return 0;
+  }
+
+  /* Which source will we use to format the string */
+  used_operation = RETURN_ERROR;
+  if (lpFormat != NULL)
+  {
+    if (dwflags == 0)
+      used_operation = USE_PARAMETER;
+  }
+  else
+  {
+    if (dwflags & LOCALE_NOUSEROVERRIDE)
+      used_operation = USE_LOCALEINFO;
+    else
+      used_operation = USE_SYSTEMDEFAULT;
+  }
+
+  /* Load the fields we need */
+  switch(used_operation)
+  {
+    case USE_LOCALEINFO:
+        GetLocaleInfoA(locale, LOCALE_IDIGITS, sNumberDigits, sizeof(sNumberDigits));
+        GetLocaleInfoA(locale, LOCALE_SDECIMAL, sDecimalSymbol, sizeof(sDecimalSymbol));
+        GetLocaleInfoA(locale, LOCALE_SGROUPING, sDigitsInGroup, sizeof(sDigitsInGroup));
+        GetLocaleInfoA(locale, LOCALE_STHOUSAND, sDigitGroupSymbol, sizeof(sDigitGroupSymbol));
+        GetLocaleInfoA(locale, LOCALE_ILZERO, sILZero, sizeof(sILZero));
+        GetLocaleInfoA(locale, LOCALE_INEGNUMBER, sNegNumber, sizeof(sNegNumber));
+        break;
+    case USE_PARAMETER:
+        sprintf(sNumberDigits, "%d",lpFormat->NumDigits);
+        strcpy(sDecimalSymbol, lpFormat->lpDecimalSep);
+        sprintf(sDigitsInGroup, "%d;0",lpFormat->Grouping);
+        strcpy(sDigitGroupSymbol, lpFormat->lpThousandSep);
+        sprintf(sILZero, "%d",lpFormat->LeadingZero);
+        sprintf(sNegNumber, "%d",lpFormat->NegativeOrder);
+        break;
+    case USE_SYSTEMDEFAULT:
+        systemDefaultLCID = GetSystemDefaultLCID();
+        GetLocaleInfoA(systemDefaultLCID, LOCALE_IDIGITS, sNumberDigits, sizeof(sNumberDigits));
+        GetLocaleInfoA(systemDefaultLCID, LOCALE_SDECIMAL, sDecimalSymbol, sizeof(sDecimalSymbol));
+        GetLocaleInfoA(systemDefaultLCID, LOCALE_SGROUPING, sDigitsInGroup, sizeof(sDigitsInGroup));
+        GetLocaleInfoA(systemDefaultLCID, LOCALE_STHOUSAND, sDigitGroupSymbol, sizeof(sDigitGroupSymbol));
+        GetLocaleInfoA(systemDefaultLCID, LOCALE_ILZERO, sILZero, sizeof(sILZero));
+        GetLocaleInfoA(systemDefaultLCID, LOCALE_INEGNUMBER, sNegNumber, sizeof(sNegNumber));
+        break;
+    default:
+        SetLastError(ERROR_INVALID_PARAMETER);
+        return 0;
+    }
+
+    nNumberDigits = atoi(sNumberDigits);
+    
+    /* Remove the ";" */
+    i=0;
+    j = 1;
+    for (nCounter=0; nCounter<strlen(sDigitsInGroup); nCounter++)
+    {
+        if ( memcmp(sDigitsInGroup + nCounter, sSemiColumn, 1) != 0 )
+        {
+            memcpy(sRule + j, sDigitsInGroup + nCounter, 1);
+            i++;
+            j++;
+        }
+    }
+    sprintf(sBuffer, "%d", i);
+    memcpy(sRule, sBuffer, 1); /* Number of digits in the groups ( used by OLE_GetGrouping() ) */
+    memcpy(sRule + j, "\0", 1);
+    
+    /* First, format the digits before the decimal. */
+    if ((nNumberDecimal>0) && (atoi(sDigitsBeforeDecimal) != 0)) 
+    {
+        /* Working on an inverted string is easier ! */
+        OLE_InvertString(sDigitsBeforeDecimal);
+
+        nStep = nCounter = i = j = 0;
+        nRuleIndex = 1;
+        nGrouping = OLE_GetGrouping(sRule, nRuleIndex);
+        
+        /* Here, we will loop until we reach the end of the string.
+         * An internal counter (j) is used in order to know when to 
+         * insert the "digit group symbol".
+         */
+        while (nNumberDecimal > 0)
+        {
+            i = nCounter + nStep;
+            memcpy(sDestination + i, sDigitsBeforeDecimal + nCounter, 1);
+            nCounter++;
+            j++;
+            if (j >= nGrouping)
+            {
+                j = 0;
+                if (nRuleIndex < sRule[0])
+                    nRuleIndex++;
+                nGrouping = OLE_GetGrouping(sRule, nRuleIndex);
+                memcpy(sDestination + i+1, sDigitGroupSymbol, strlen(sDigitGroupSymbol));
+                nStep+= strlen(sDigitGroupSymbol);
+            }
+
+            nNumberDecimal--;
+        }
+
+        memcpy(sDestination + i+1, "\0", 1);
+        /* Get the string in the right order ! */
+        OLE_InvertString(sDestination);
+     }
+     else
+     {
+        nLZ = atoi(sILZero);
+        if (nLZ != 0)
+        {        
+            /* Use 0.xxx instead of .xxx */
+            memcpy(sDestination, "0", 1);
+            memcpy(sDestination+1, "\0", 1);
+        }
+        else
+            memcpy(sDestination, "\0", 1);
+
+     }
+
+    /* Second, format the digits after the decimal. */
+    j = 0;
+    nCounter = nNumberDigits;
+    if ( (nDigits>0) && (pStr = strstr (sNumber, ".")) )
+    {
+        i = strlen(sNumber) - strlen(pStr) + 1;        
+        strncpy ( sDigitsAfterDecimal, sNumber + i, nNumberDigits);
+        j = strlen(sDigitsAfterDecimal);
+        if (j < nNumberDigits)
+            nCounter = nNumberDigits-j;            
+    }
+    for (i=0;i<nCounter;i++)
+         memcpy(sDigitsAfterDecimal+i+j, "0", 1);    
+    memcpy(sDigitsAfterDecimal + nNumberDigits, "\0", 1);    
+
+    i = strlen(sDestination);
+    j = strlen(sDigitsAfterDecimal);
+    /* Finally, construct the resulting formatted string. */
+        
+    for (nCounter=0; nCounter<i; nCounter++)
+        memcpy(sNumber + nCounter, sDestination + nCounter, 1);
+       
+    memcpy(sNumber + nCounter, sDecimalSymbol, strlen(sDecimalSymbol));
+
+    for (i=0; i<j; i++)
+        memcpy(sNumber + nCounter+i+strlen(sDecimalSymbol), sDigitsAfterDecimal + i, 1);
+    memcpy(sNumber + nCounter+i+strlen(sDecimalSymbol), "\0", 1);
+        
+    /* Is it a negative number */
+    if (bNegative == TRUE)
+    {
+        i = atoi(sNegNumber);
+        pStr = sDestination;
+        pTmpStr = sNumber;
+        switch (i)
+        {          
+        case 0:
+            *pStr++ = '(';
+            while (*sNumber != '\0')
+                *pStr++ =  *pTmpStr++;
+            *pStr++ = ')';                
+            break;  
+        case 1:
+            *pStr++ = '-';
+            while (*pTmpStr != '\0')
+                *pStr++ =  *pTmpStr++;
+            break;
+        case 2:
+            *pStr++ = '-';
+            *pStr++ = ' ';
+            while (*pTmpStr != '\0')
+                *pStr++ =  *pTmpStr++;
+            break;
+        case 3:
+            while (*pTmpStr != '\0')
+                *pStr++ =  *pTmpStr++;
+            *pStr++ = '-';
+            break;
+        case 4:
+            while (*pTmpStr != '\0')
+                *pStr++ =  *pTmpStr++;
+            *pStr++ = ' ';
+            *pStr++ = '-';
+            break;
+        default:
+            while (*pTmpStr != '\0')
+                *pStr++ =  *pTmpStr++;
+            break;
+        }
+    }
+    else
+        strcpy(sDestination, sNumber);
+
+    /* If cchNumber is zero, then returns the number of bytes or characters 
+     * required to hold the formatted number string
+     */
+    if (cchNumber==0)
+        retVal = strlen(sDestination) + 1;
+    else           
+    {
+        strncpy (lpNumberStr, sDestination, cchNumber-1);
+        *(lpNumberStr+cchNumber-1) = '\0';   /* ensure we got a NULL at the end */
+        retVal = strlen(lpNumberStr);
+    }
+          
+    return retVal;
+}
+
+
 
 
@@ -1103 +1451 @@
 
 int WIN32API GetNumberFormatW(LCID     Locale,
-                                 DWORD    dwFlags,
-                                 LPCWSTR lpValue,
-                                 CONST NUMBERFMTW *lpFormat,
-                                 LPWSTR  lpNumberStr,
-                                 int      cchNumber)
+                              DWORD    dwFlags,
+                              LPCWSTR lpValue,
+                              CONST NUMBERFMTW *lpFormat,
+                              LPWSTR  lpNumberStr,
+                              int      cchNumber)
 {
   dprintf(("GetNumberFormatW(%08x,%08x,%s,%08x,%s,%08x) not properly implemented.\n",