Update ICU to 54.1 step 1

source/common/udata.cpp

 /*
 ******************************************************************************
 *
-*   Copyright (C) 1999-2013, International Business Machines
+*   Copyright (C) 1999-2014, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 ******************************************************************************
 *   file name:  udata.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 1999oct25
 *   created by: Markus W. Scherer
@@ skipping 49 matching lines @@
 
 /* configuration ---------------------------------------------------------- */
 
 /* If you are excruciatingly bored turn this on .. */
 /* #define UDATA_DEBUG 1 */
 
 #if defined(UDATA_DEBUG)
 #   include <stdio.h>
 #endif
 
-#define LENGTHOF(array) (int32_t)(sizeof(array)/sizeof((array)[0]))
-
 U_NAMESPACE_USE
 
 /*
  *  Forward declarations
  */
 static UDataMemory *udata_findCachedData(const char *path);
 
 /***********************************************************************
 *
 *    static (Global) data
@@ skipping 29 matching lines @@
 udata_cleanup(void)
 {
     int32_t i;
 
     if (gCommonDataCache) {             /* Delete the cache of user data mappings.  */
         uhash_close(gCommonDataCache);  /*   Table owns the contents, and will delete them. */
         gCommonDataCache = NULL;        /*   Cleanup is not thread safe.                */
     }
     gCommonDataCacheInitOnce.reset();
 
-    for (i = 0; i < LENGTHOF(gCommonICUDataArray) && gCommonICUDataArray[i] != NULL; ++i) {
+    for (i = 0; i < UPRV_LENGTHOF(gCommonICUDataArray) && gCommonICUDataArray[i] != NULL; ++i) {
         udata_close(gCommonICUDataArray[i]);
         gCommonICUDataArray[i] = NULL;
     }
     gHaveTriedToLoadCommonData = FALSE;
 
     return TRUE;                   /* Everything was cleaned up */
 }
 
 static UBool U_CALLCONV
 findCommonICUDataByName(const char *inBasename)
 {
     UBool found = FALSE;
     int32_t i;
 
     UDataMemory  *pData = udata_findCachedData(inBasename);
     if (pData == NULL)
         return FALSE;
 
-    for (i = 0; i < LENGTHOF(gCommonICUDataArray); ++i) {
+    for (i = 0; i < UPRV_LENGTHOF(gCommonICUDataArray); ++i) {
         if ((gCommonICUDataArray[i] != NULL) && (gCommonICUDataArray[i]->pHeader == pData->pHeader)) {
             /* The data pointer is already in the array. */
             found = TRUE;
             break;
         }
     }
 
     return found;
 }
 
@@ skipping 13 matching lines @@
     if (U_FAILURE(*pErr)) {
         return FALSE;
     }
 
     /*  For the assignment, other threads must cleanly see either the old            */
     /*    or the new, not some partially initialized new.  The old can not be        */
     /*    deleted - someone may still have a pointer to it lying around in           */
     /*    their locals.                                                              */
     UDatamemory_assign(newCommonData, pData);
     umtx_lock(NULL);
-    for (i = 0; i < LENGTHOF(gCommonICUDataArray); ++i) {
+    for (i = 0; i < UPRV_LENGTHOF(gCommonICUDataArray); ++i) {
         if (gCommonICUDataArray[i] == NULL) {
             gCommonICUDataArray[i] = newCommonData;
-            ucln_common_registerCleanup(UCLN_COMMON_UDATA, udata_cleanup);
             didUpdate = TRUE;
             break;
         } else if (gCommonICUDataArray[i]->pHeader == pData->pHeader) {
             /* The same data pointer is already in the array. */
             break;
         }
     }
     umtx_unlock(NULL);
 
-    if (i == LENGTHOF(gCommonICUDataArray) && warn) {
+    if (i == UPRV_LENGTHOF(gCommonICUDataArray) && warn) {
         *pErr = U_USING_DEFAULT_WARNING;
     }
-    if (!didUpdate) {
+    if (didUpdate) {
+        ucln_common_registerCleanup(UCLN_COMMON_UDATA, udata_cleanup);
+    } else {
         uprv_free(newCommonData);
     }
     return didUpdate;
 }
 
 static UBool
 setCommonICUDataPointer(const void *pData, UBool /*warn*/, UErrorCode *pErrorCode) {
     UDataMemory tData;
     UDataMemory_init(&tData);
     UDataMemory_setData(&tData, pData);
@@ skipping 409 matching lines @@
 /* ==================================================================================*/
 
 
 /*----------------------------------------------------------------------*
  *                                                                      *
  *  Add a static reference to the common data  library                  *
  *   Unless overridden by an explicit udata_setCommonData, this will be *
  *      our common data.                                                *
  *                                                                      *
  *----------------------------------------------------------------------*/
-extern "C" const ICU_Data_Header U_DATA_API U_ICUDATA_ENTRY_POINT;
+extern "C" const DataHeader U_DATA_API U_ICUDATA_ENTRY_POINT;
 
 /*
  * This would be a good place for weak-linkage declarations of
  * partial-data-library access functions where each returns a pointer
  * to its data package, if it is linked in.
  */
 /*
 extern const void *uprv_getICUData_collation(void) ATTRIBUTE_WEAK;
 extern const void *uprv_getICUData_conversion(void) ATTRIBUTE_WEAK;
 */
@@ skipping 19 matching lines @@
 
     if (U_FAILURE(*pErrorCode)) {
         return NULL;
     }
 
     UDataMemory_init(&tData);
 
     /* ??????? TODO revisit this */ 
     if (commonDataIndex >= 0) {
         /* "mini-cache" for common ICU data */
-        if(commonDataIndex >= LENGTHOF(gCommonICUDataArray)) {
+        if(commonDataIndex >= UPRV_LENGTHOF(gCommonICUDataArray)) {
             return NULL;
         }
         if(gCommonICUDataArray[commonDataIndex] == NULL) {
             int32_t i;
             for(i = 0; i < commonDataIndex; ++i) {
-                if(gCommonICUDataArray[i]->pHeader == &U_ICUDATA_ENTRY_POINT.hdr) {
+                if(gCommonICUDataArray[i]->pHeader == &U_ICUDATA_ENTRY_POINT) {
                     /* The linked-in data is already in the list. */
                     return NULL;
                 }
             }
 
             /* Add the linked-in data to the list. */
             /*
              * This is where we would check and call weakly linked partial-data-library
              * access functions.
              */
             /*
             if (uprv_getICUData_collation) {
                 setCommonICUDataPointer(uprv_getICUData_collation(), FALSE, pErrorCode);
             }
             if (uprv_getICUData_conversion) {
                 setCommonICUDataPointer(uprv_getICUData_conversion(), FALSE, pErrorCode);
             }
             */
-            setCommonICUDataPointer(&U_ICUDATA_ENTRY_POINT.hdr, FALSE, pErrorCode);
+            setCommonICUDataPointer(&U_ICUDATA_ENTRY_POINT, FALSE, pErrorCode);
         }
         return gCommonICUDataArray[commonDataIndex];
     }
 
 
     /* request is NOT for ICU Data.  */
 
     /* Find the base name portion of the supplied path.   */
     /*   inBasename will be left pointing somewhere within the original path string.      */
     inBasename = findBasename(path);
@@ skipping 359 matching lines @@
         } else if ((!checkedExtendedICUData) && extendICUData(subErrorCode)) {
             checkedExtendedICUData = TRUE;
             /* try this data package slot again: it changed from NULL to non-NULL */
         } else {
             return NULL;
         }
     }
 }
 
 /*
+ * Identify the Time Zone resources that are subject to special override data loading.
+ */
+static UBool isTimeZoneFile(const char *name, const char *type) {
+    return ((uprv_strcmp(type, "res") == 0) &&
+            (uprv_strcmp(name, "zoneinfo64") == 0 ||
+             uprv_strcmp(name, "timezoneTypes") == 0 ||
+             uprv_strcmp(name, "windowsZones") == 0 ||
+             uprv_strcmp(name, "metaZones") == 0));
+}
+
+/*
  *  A note on the ownership of Mapped Memory
  *
  *  For common format files, ownership resides with the UDataMemory object
  *    that lives in the cache of opened common data.  These UDataMemorys are private
  *    to the udata implementation, and are never seen directly by users.
  *
  *    The UDataMemory objects returned to users will have the address of some desired
  *    data within the mapped region, but they wont have the mapping info itself, and thus
  *    won't cause anything to be removed from memory when they are closed.
  *
@@ skipping 147 matching lines @@
     }
 
     /************************ Begin loop looking for ind. files ***************/
 #ifdef UDATA_DEBUG
     fprintf(stderr, "IND: inBasename = %s, pkg=%s\n", "(n/a)", packageNameFromPath(path));
 #endif
 
     /* End of dealing with a null basename */
     dataPath = u_getDataDirectory();
 
+    /****    Time zone individual files override  */
+    if (isTimeZoneFile(name, type) && isICUData) {
+        const char *tzFilesDir = u_getTimeZoneFilesDirectory(pErrorCode);
+        if (tzFilesDir[0] != 0) {
+#ifdef UDATA_DEBUG
+            fprintf(stderr, "Trying Time Zone Files directory = %s\n", tzFilesDir);
+#endif
+            retVal = doLoadFromIndividualFiles(/* pkgName.data() */ "", tzFilesDir, tocEntryPathSuffix,
+                            /* path */ "", type, name, isAcceptable, context, &subErrorCode, pErrorCode);
+            if((retVal != NULL) || U_FAILURE(*pErrorCode)) {
+                return retVal;
+            }
+        }
+    }
+
     /****    COMMON PACKAGE  - only if packages are first. */
     if(gDataFileAccess == UDATA_PACKAGES_FIRST) {
 #ifdef UDATA_DEBUG
         fprintf(stderr, "Trying packages (UDATA_PACKAGES_FIRST)\n");
 #endif
         /* #2 */
         retVal = doLoadFromCommonData(isICUData, 
                             pkgName.data(), dataPath, tocEntryPathSuffix, tocEntryName.data(),
                             path, type, name, isAcceptable, context, &subErrorCode, pErrorCode);
         if((retVal != NULL) || U_FAILURE(*pErrorCode)) {
@@ skipping 122 matching lines @@
             pInfo->size=0;
         }
     }
 }
 
 
 U_CAPI void U_EXPORT2 udata_setFileAccess(UDataFileAccess access, UErrorCode * /*status*/)
 {
     gDataFileAccess = access;
 }