ICU 56 update step 1

source/tools/toolutil/package.cpp

 /*
 *******************************************************************************
 *
-*   Copyright (C) 1999-2014, International Business Machines
+*   Copyright (C) 1999-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
 *   file name:  package.cpp
 *   encoding:   US-ASCII
 *   tab size:   8 (not used)
 *   indentation:4
 *
 *   created on: 2005aug25
 *   created by: Markus W. Scherer
@@ skipping 282 matching lines @@
             }
         }
         *sep++=U_FILE_SEP_CHAR; // restore file separator character
     }
 }
 
 static uint8_t *
 readFile(const char *path, const char *name, int32_t &length, char &type) {
     char filename[1024];
     FILE *file;
-    uint8_t *data;
     UErrorCode errorCode;
     int32_t fileLength, typeEnum;
 
     makeFullFilename(path, name, filename, (int32_t)sizeof(filename));
 
     /* open the input file, get its length, allocate memory for it, read the file */
     file=fopen(filename, "rb");
     if(file==NULL) {
         fprintf(stderr, "icupkg: unable to open input file \"%s\"\n", filename);
         exit(U_FILE_ACCESS_ERROR);
     }
 
     /* get the file length */
     fileLength=getFileLength(file);
     if(ferror(file) || fileLength<=0) {
         fprintf(stderr, "icupkg: empty input file \"%s\"\n", filename);
         fclose(file);
         exit(U_FILE_ACCESS_ERROR);
     }
 
     /* allocate the buffer, pad to multiple of 16 */
     length=(fileLength+0xf)&~0xf;
-    data=(uint8_t *)uprv_malloc(length);
-    if(data==NULL) {
+    icu::LocalMemory<uint8_t> data((uint8_t *)uprv_malloc(length));
+    if(data.isNull()) {
         fclose(file);
         fprintf(stderr, "icupkg: malloc error allocating %d bytes.\n", (int)length);
         exit(U_MEMORY_ALLOCATION_ERROR);
     }
 
     /* read the file */
-    if(fileLength!=(int32_t)fread(data, 1, fileLength, file)) {
+    if(fileLength!=(int32_t)fread(data.getAlias(), 1, fileLength, file)) {
         fprintf(stderr, "icupkg: error reading \"%s\"\n", filename);
         fclose(file);
-        free(data);
         exit(U_FILE_ACCESS_ERROR);
     }
 
     /* pad the file to a multiple of 16 using the usual padding byte */
     if(fileLength<length) {
-        memset(data+fileLength, 0xaa, length-fileLength);
+        memset(data.getAlias()+fileLength, 0xaa, length-fileLength);
     }
 
     fclose(file);
 
     // minimum check for ICU-format data
     errorCode=U_ZERO_ERROR;
-    typeEnum=getTypeEnumForInputData(data, length, &errorCode);
+    typeEnum=getTypeEnumForInputData(data.getAlias(), length, &errorCode);
     if(typeEnum<0 || U_FAILURE(errorCode)) {
         fprintf(stderr, "icupkg: not an ICU data file: \"%s\"\n", filename);
-        free(data);
 #if !UCONFIG_NO_LEGACY_CONVERSION
         exit(U_INVALID_FORMAT_ERROR);
 #else
         fprintf(stderr, "U_INVALID_FORMAT_ERROR occurred but UCONFIG_NO_LEGACY_CONVERSION is on so this is expected.\n");
         exit(0);
 #endif
     }
     type=makeTypeLetter(typeEnum);
 
-    return data;
+    return data.orphan();
 }
 
 // .dat package file representation ---------------------------------------- ***
 
 U_CDECL_BEGIN
 
 static int32_t U_CALLCONV
 compareItems(const void * /*context*/, const void *left, const void *right) {
     U_NAMESPACE_USE
 
@@ skipping 36 matching lines @@
         int32_t length=(headerLength+0xf)&~0xf;
         memset(header+headerLength, 0, length-headerLength);
         headerLength=length;
     }
     pHeader->dataHeader.headerSize=(uint16_t)headerLength;
 }
 
 Package::~Package() {
     int32_t idx;
 
-    free(inData);
+    uprv_free(inData);
 
     for(idx=0; idx<itemCount; ++idx) {
         if(items[idx].isDataOwned) {
-            free(items[idx].data);
+            uprv_free(items[idx].data);
         }
     }
 
     uprv_free((void*)items);
 }
 
 void
 Package::setPrefix(const char *p) {
     if(strlen(p)>=sizeof(pkgPrefix)) {
         fprintf(stderr, "icupkg: --toc_prefix %s too long\n", p);
@@ skipping 604 matching lines @@
         // reset this Item entry
         memset(items+idx, 0, sizeof(Item));
 
         // copy the item's name
         items[idx].name=allocString(TRUE, strlen(name));
         strcpy(items[idx].name, name);
         pathToTree(items[idx].name);
     } else {
         // same-name item found, replace it
         if(items[idx].isDataOwned) {
-            free(items[idx].data);
+            uprv_free(items[idx].data);
         }
 
         // keep the item's name since it is the same
     }
 
     // set the item's data
     items[idx].data=data;
     items[idx].length=length;
     items[idx].isDataOwned=isDataOwned;
     items[idx].type=type;
@@ skipping 18 matching lines @@
     for(pItem=listPkg.items, i=0; i<listPkg.itemCount; ++pItem, ++i) {
         addItem(pItem->name, pItem->data, pItem->length, FALSE, pItem->type);
     }
 }
 
 void
 Package::removeItem(int32_t idx) {
     if(idx>=0) {
         // remove the item
         if(items[idx].isDataOwned) {
-            free(items[idx].data);
+            uprv_free(items[idx].data);
         }
 
         // move the following items up
         if((idx+1)<itemCount) {
             memmove(items+idx, items+idx+1, (itemCount-(idx+1))*sizeof(Item));
         }
         --itemCount;
 
         if(idx<=findNextIndex) {
             --findNextIndex;
@@ skipping 200 matching lines @@
 }
 
 void Package::ensureItemCapacity()
 {
   if((itemCount+1)>itemMax) {
     setItemCapacity(itemCount+kItemsChunk);
   }
 }
 
 U_NAMESPACE_END