diff --git a/icu4c/source/i18n/cpdtrans.h b/icu4c/source/i18n/cpdtrans.h
index 833b2cb8198..e964d4cc3af 100644
--- a/icu4c/source/i18n/cpdtrans.h
+++ b/icu4c/source/i18n/cpdtrans.h
@@ -1,6 +1,6 @@
 /*
 **********************************************************************
-*   Copyright (C) 1999-2007, International Business Machines
+*   Copyright (C) 1999-2009, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 **********************************************************************
 *   Date        Name        Description
@@ -114,11 +114,11 @@ public:
 
     /**
      * Returns the transliterator at the given index in this chain.
-     * @param index index into chain, from 0 to <code>getCount() - 1</code>
+     * @param idx index into chain, from 0 to <code>getCount() - 1</code>
      * @return transliterator at the given index
      * @internal Use transliterator factory methods instead since this class will be removed in that release.
      */
-    virtual const Transliterator& getTransliterator(int32_t index) const;
+    virtual const Transliterator& getTransliterator(int32_t idx) const;
 
     /**
      * Sets the transliterators.
@@ -166,7 +166,7 @@ protected:
      * Implements {@link Transliterator#handleTransliterate}.
      * @internal Use transliterator factory methods instead since this class will be removed in that release.
      */
-    virtual void handleTransliterate(Replaceable& text, UTransPosition& index,
+    virtual void handleTransliterate(Replaceable& text, UTransPosition& idx,
                                      UBool incremental) const;
 
 public:
diff --git a/icu4c/source/tools/makeconv/genmbcs.c b/icu4c/source/tools/makeconv/genmbcs.c
index 2d64bfc013f..696ce4fe95c 100644
--- a/icu4c/source/tools/makeconv/genmbcs.c
+++ b/icu4c/source/tools/makeconv/genmbcs.c
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 *
-*   Copyright (C) 2000-2008, International Business Machines
+*   Copyright (C) 2000-2009, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
@@ -559,7 +559,7 @@ MBCSSingleAddFromUnicode(MBCSData *mbcsData,
                          UChar32 c,
                          int8_t flag) {
     uint16_t *stage3, *p;
-    uint32_t index;
+    uint32_t idx;
     uint16_t old;
     uint8_t b;
 
@@ -580,13 +580,13 @@ MBCSSingleAddFromUnicode(MBCSData *mbcsData,
     b=*bytes;
 
     /* inspect stage 1 */
-    index=c>>MBCS_STAGE_1_SHIFT;
+    idx=c>>MBCS_STAGE_1_SHIFT;
     if(mbcsData->utf8Friendly && c<=SBCS_UTF8_MAX) {
         nextOffset=(c>>MBCS_STAGE_2_SHIFT)&MBCS_STAGE_2_BLOCK_MASK&~(MBCS_UTF8_STAGE_3_BLOCKS-1);
     } else {
         nextOffset=(c>>MBCS_STAGE_2_SHIFT)&MBCS_STAGE_2_BLOCK_MASK;
     }
-    if(mbcsData->stage1[index]==MBCS_STAGE_2_ALL_UNASSIGNED_INDEX) {
+    if(mbcsData->stage1[idx]==MBCS_STAGE_2_ALL_UNASSIGNED_INDEX) {
         /* allocate another block in stage 2 */
         newBlock=mbcsData->stage2Top;
         if(mbcsData->utf8Friendly) {
@@ -606,12 +606,12 @@ MBCSSingleAddFromUnicode(MBCSData *mbcsData,
          * each stage 2 block contains 64 16-bit words:
          * 6 code point bits 9..4 with 1 stage 3 index
          */
-        mbcsData->stage1[index]=(uint16_t)newBlock;
+        mbcsData->stage1[idx]=(uint16_t)newBlock;
         mbcsData->stage2Top=newTop;
     }
 
     /* inspect stage 2 */
-    index=mbcsData->stage1[index]+nextOffset;
+    idx=mbcsData->stage1[idx]+nextOffset;
     if(mbcsData->utf8Friendly && c<=SBCS_UTF8_MAX) {
         /* allocate 64-entry blocks for UTF-8-friendly lookup */
         blockSize=MBCS_UTF8_STAGE_3_BLOCK_SIZE;
@@ -620,7 +620,7 @@ MBCSSingleAddFromUnicode(MBCSData *mbcsData,
         blockSize=MBCS_STAGE_3_BLOCK_SIZE;
         nextOffset=c&MBCS_STAGE_3_BLOCK_MASK;
     }
-    if(mbcsData->stage2Single[index]==0) {
+    if(mbcsData->stage2Single[idx]==0) {
         /* allocate another block in stage 3 */
         newBlock=mbcsData->stage3Top;
         if(mbcsData->utf8Friendly) {
@@ -636,7 +636,7 @@ MBCSSingleAddFromUnicode(MBCSData *mbcsData,
             return FALSE;
         }
         /* each block has 16 uint16_t entries */
-        i=index;
+        i=idx;
         while(newBlock<newTop) {
             mbcsData->stage2Single[i++]=(uint16_t)newBlock;
             newBlock+=MBCS_STAGE_3_BLOCK_SIZE;
@@ -645,7 +645,7 @@ MBCSSingleAddFromUnicode(MBCSData *mbcsData,
     }
 
     /* write the codepage entry into stage 3 and get the previous entry */
-    p=stage3+mbcsData->stage2Single[index]+nextOffset;
+    p=stage3+mbcsData->stage2Single[idx]+nextOffset;
     old=*p;
     if(flag<=0) {
         *p=(uint16_t)(0xf00|b);
@@ -679,7 +679,7 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
     char buffer[10];
     const uint8_t *pb;
     uint8_t *stage3, *p;
-    uint32_t index, b, old, stage3Index;
+    uint32_t idx, b, old, stage3Index;
     int32_t maxCharLength;
 
     uint32_t blockSize, newTop, i, nextOffset, newBlock, min, overlap, maxOverlap;
@@ -710,13 +710,13 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
     stage3=mbcsData->fromUBytes;
 
     /* inspect stage 1 */
-    index=c>>MBCS_STAGE_1_SHIFT;
+    idx=c>>MBCS_STAGE_1_SHIFT;
     if(mbcsData->utf8Friendly && c<=mbcsData->utf8Max) {
         nextOffset=(c>>MBCS_STAGE_2_SHIFT)&MBCS_STAGE_2_BLOCK_MASK&~(MBCS_UTF8_STAGE_3_BLOCKS-1);
     } else {
         nextOffset=(c>>MBCS_STAGE_2_SHIFT)&MBCS_STAGE_2_BLOCK_MASK;
     }
-    if(mbcsData->stage1[index]==MBCS_STAGE_2_ALL_UNASSIGNED_INDEX) {
+    if(mbcsData->stage1[idx]==MBCS_STAGE_2_ALL_UNASSIGNED_INDEX) {
         /* allocate another block in stage 2 */
         newBlock=mbcsData->stage2Top;
         if(mbcsData->utf8Friendly) {
@@ -737,7 +737,7 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
          * each stage 2 block contains 64 32-bit words:
          * 6 code point bits 9..4 with value with bits 31..16 "assigned" flags and bits 15..0 stage 3 index
          */
-        i=index;
+        i=idx;
         while(newBlock<newTop) {
             mbcsData->stage1[i++]=(uint16_t)newBlock;
             newBlock+=MBCS_STAGE_2_BLOCK_SIZE;
@@ -746,7 +746,7 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
     }
 
     /* inspect stage 2 */
-    index=mbcsData->stage1[index]+nextOffset;
+    idx=mbcsData->stage1[idx]+nextOffset;
     if(mbcsData->utf8Friendly && c<=mbcsData->utf8Max) {
         /* allocate 64-entry blocks for UTF-8-friendly lookup */
         blockSize=MBCS_UTF8_STAGE_3_BLOCK_SIZE*maxCharLength;
@@ -755,7 +755,7 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
         blockSize=MBCS_STAGE_3_BLOCK_SIZE*maxCharLength;
         nextOffset=c&MBCS_STAGE_3_BLOCK_MASK;
     }
-    if(mbcsData->stage2[index]==0) {
+    if(mbcsData->stage2[idx]==0) {
         /* allocate another block in stage 3 */
         newBlock=mbcsData->stage3Top;
         if(mbcsData->utf8Friendly && nextOffset>=MBCS_STAGE_3_GRANULARITY) {
@@ -781,7 +781,7 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
             return FALSE;
         }
         /* each block has 16*maxCharLength bytes */
-        i=index;
+        i=idx;
         while(newBlock<newTop) {
             mbcsData->stage2[i++]=(newBlock/MBCS_STAGE_3_GRANULARITY)/maxCharLength;
             newBlock+=MBCS_STAGE_3_BLOCK_SIZE*maxCharLength;
@@ -789,7 +789,7 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
         mbcsData->stage3Top=newTop; /* ==newBlock */
     }
 
-    stage3Index=MBCS_STAGE_3_GRANULARITY*(uint32_t)(uint16_t)mbcsData->stage2[index];
+    stage3Index=MBCS_STAGE_3_GRANULARITY*(uint32_t)(uint16_t)mbcsData->stage2[idx];
 
     /* Build an alternate, UTF-8-friendly stage table as well. */
     if(mbcsData->utf8Friendly && c<=mbcsData->utf8Max) {
@@ -866,7 +866,7 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
     }
 
     /* check that this Unicode code point was still unassigned */
-    if((mbcsData->stage2[index+(nextOffset>>MBCS_STAGE_2_SHIFT)]&(1UL<<(16+(c&0xf))))!=0 || old!=0) {
+    if((mbcsData->stage2[idx+(nextOffset>>MBCS_STAGE_2_SHIFT)]&(1UL<<(16+(c&0xf))))!=0 || old!=0) {
         if(flag>=0) {
             fprintf(stderr, "error: duplicate Unicode code point at U+%04x<->0x%s see 0x%02x\n",
                 (int)c, printBytes(buffer, bytes, length), (int)old);
@@ -880,7 +880,7 @@ MBCSAddFromUnicode(MBCSData *mbcsData,
     }
     if(flag<=0) {
         /* set the roundtrip flag */
-        mbcsData->stage2[index+(nextOffset>>4)]|=(1UL<<(16+(c&0xf)));
+        mbcsData->stage2[idx+(nextOffset>>4)]|=(1UL<<(16+(c&0xf)));
     }
 
     return TRUE;
diff --git a/icu4c/source/tools/toolutil/package.cpp b/icu4c/source/tools/toolutil/package.cpp
index c5db3017338..cffedfbe8a1 100644
--- a/icu4c/source/tools/toolutil/package.cpp
+++ b/icu4c/source/tools/toolutil/package.cpp
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 *
-*   Copyright (C) 1999-2007, International Business Machines
+*   Copyright (C) 1999-2009, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
@@ -406,13 +406,13 @@ Package::Package() {
 }
 
 Package::~Package() {
-    int32_t index;
+    int32_t idx;
 
     free(inData);
 
-    for(index=0; index<itemCount; ++index) {
-        if(items[index].isDataOwned) {
-            free(items[index].data);
+    for(idx=0; idx<itemCount; ++idx) {
+        if(items[idx].isDataOwned) {
+            free(items[idx].data);
         }
     }
 }
@@ -902,15 +902,15 @@ Package::findItems(const char *pattern) {
 int32_t
 Package::findNextItem() {
     const char *name, *middle, *treeSep;
-    int32_t index, nameLength, middleLength;
+    int32_t idx, nameLength, middleLength;
 
     if(findNextIndex<0) {
         return -1;
     }
 
     while(findNextIndex<itemCount) {
-        index=findNextIndex++;
-        name=items[index].name;
+        idx=findNextIndex++;
+        name=items[idx].name;
         nameLength=(int32_t)strlen(name);
         if(nameLength<(findPrefixLength+findSuffixLength)) {
             // item name too short for prefix & suffix
@@ -937,7 +937,7 @@ Package::findNextItem() {
         }
 
         // found a matching item
-        return index;
+        return idx;
     }
 
     // no more items
@@ -957,43 +957,43 @@ Package::addItem(const char *name) {
 
 void
 Package::addItem(const char *name, uint8_t *data, int32_t length, UBool isDataOwned, char type) {
-    int32_t index;
+    int32_t idx;
 
-    index=findItem(name);
-    if(index<0) {
+    idx=findItem(name);
+    if(idx<0) {
         // new item, make space at the insertion point
         if(itemCount>=MAX_FILE_COUNT) {
             fprintf(stderr, "icupkg: too many items, maximum is %d\n", MAX_FILE_COUNT);
             exit(U_BUFFER_OVERFLOW_ERROR);
         }
         // move the following items down
-        index=~index;
-        if(index<itemCount) {
-            memmove(items+index+1, items+index, (itemCount-index)*sizeof(Item));
+        idx=~idx;
+        if(idx<itemCount) {
+            memmove(items+idx+1, items+idx, (itemCount-idx)*sizeof(Item));
         }
         ++itemCount;
 
         // reset this Item entry
-        memset(items+index, 0, sizeof(Item));
+        memset(items+idx, 0, sizeof(Item));
 
         // copy the item's name
-        items[index].name=allocString(TRUE, strlen(name));
-        strcpy(items[index].name, name);
-        pathToTree(items[index].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[index].isDataOwned) {
-            free(items[index].data);
+        if(items[idx].isDataOwned) {
+            free(items[idx].data);
         }
 
         // keep the item's name since it is the same
     }
 
     // set the item's data
-    items[index].data=data;
-    items[index].length=length;
-    items[index].isDataOwned=isDataOwned;
-    items[index].type=type;
+    items[idx].data=data;
+    items[idx].length=length;
+    items[idx].isDataOwned=isDataOwned;
+    items[idx].type=type;
 }
 
 void
@@ -1018,20 +1018,20 @@ Package::addItems(const Package &listPkg) {
 }
 
 void
-Package::removeItem(int32_t index) {
-    if(index>=0) {
+Package::removeItem(int32_t idx) {
+    if(idx>=0) {
         // remove the item
-        if(items[index].isDataOwned) {
-            free(items[index].data);
+        if(items[idx].isDataOwned) {
+            free(items[idx].data);
         }
 
         // move the following items up
-        if((index+1)<itemCount) {
-            memmove(items+index, items+index+1, (itemCount-(index+1))*sizeof(Item));
+        if((idx+1)<itemCount) {
+            memmove(items+idx, items+idx+1, (itemCount-(idx+1))*sizeof(Item));
         }
         --itemCount;
 
-        if(index<=findNextIndex) {
+        if(idx<=findNextIndex) {
             --findNextIndex;
         }
     }
@@ -1039,11 +1039,11 @@ Package::removeItem(int32_t index) {
 
 void
 Package::removeItems(const char *pattern) {
-    int32_t index;
+    int32_t idx;
 
     findItems(pattern);
-    while((index=findNextItem())>=0) {
-        removeItem(index);
+    while((idx=findNextItem())>=0) {
+        removeItem(idx);
     }
 }
 
@@ -1058,7 +1058,7 @@ Package::removeItems(const Package &listPkg) {
 }
 
 void
-Package::extractItem(const char *filesPath, const char *outName, int32_t index, char outType) {
+Package::extractItem(const char *filesPath, const char *outName, int32_t idx, char outType) {
     char filename[1024];
     UDataSwapper *ds;
     FILE *file;
@@ -1067,10 +1067,10 @@ Package::extractItem(const char *filesPath, const char *outName, int32_t index,
     uint8_t itemCharset, outCharset;
     UBool itemIsBigEndian, outIsBigEndian;
 
-    if(index<0 || itemCount<=index) {
+    if(idx<0 || itemCount<=idx) {
         return;
     }
-    pItem=items+index;
+    pItem=items+idx;
 
     // swap the data to the outType
     // outType==0: don't swap
@@ -1082,7 +1082,7 @@ Package::extractItem(const char *filesPath, const char *outName, int32_t index,
         ds=udata_openSwapper(itemIsBigEndian, itemCharset, outIsBigEndian, outCharset, &errorCode);
         if(U_FAILURE(errorCode)) {
             fprintf(stderr, "icupkg: udata_openSwapper(item %ld) failed - %s\n",
-                    (long)index, u_errorName(errorCode));
+                    (long)idx, u_errorName(errorCode));
             exit(errorCode);
         }
 
@@ -1092,7 +1092,7 @@ Package::extractItem(const char *filesPath, const char *outName, int32_t index,
         // swap the item from its platform properties to the desired ones
         udata_swap(ds, pItem->data, pItem->length, pItem->data, &errorCode);
         if(U_FAILURE(errorCode)) {
-            fprintf(stderr, "icupkg: udata_swap(item %ld) failed - %s\n", (long)index, u_errorName(errorCode));
+            fprintf(stderr, "icupkg: udata_swap(item %ld) failed - %s\n", (long)idx, u_errorName(errorCode));
             exit(errorCode);
         }
         udata_closeSwapper(ds);
@@ -1115,17 +1115,17 @@ Package::extractItem(const char *filesPath, const char *outName, int32_t index,
 }
 
 void
-Package::extractItem(const char *filesPath, int32_t index, char outType) {
-    extractItem(filesPath, items[index].name, index, outType);
+Package::extractItem(const char *filesPath, int32_t idx, char outType) {
+    extractItem(filesPath, items[idx].name, idx, outType);
 }
 
 void
 Package::extractItems(const char *filesPath, const char *pattern, char outType) {
-    int32_t index;
+    int32_t idx;
 
     findItems(pattern);
-    while((index=findNextItem())>=0) {
-        extractItem(filesPath, index, outType);
+    while((idx=findNextItem())>=0) {
+        extractItem(filesPath, idx, outType);
     }
 }
 
diff --git a/icu4c/source/tools/toolutil/package.h b/icu4c/source/tools/toolutil/package.h
index 067397d8b33..41dce133203 100644
--- a/icu4c/source/tools/toolutil/package.h
+++ b/icu4c/source/tools/toolutil/package.h
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 *
-*   Copyright (C) 2005-2007, International Business Machines
+*   Copyright (C) 2005-2009, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
@@ -97,17 +97,17 @@ public:
     void addFile(const char *filesPath, const char *name);
     void addItems(const Package &listPkg);
 
-    void removeItem(int32_t index);
+    void removeItem(int32_t itemIndex);
     void removeItems(const char *pattern);
     void removeItems(const Package &listPkg);
 
     /* The extractItem() functions accept outputType=0 to mean "don't swap the item". */
-    void extractItem(const char *filesPath, int32_t index, char outType);
+    void extractItem(const char *filesPath, int32_t itemIndex, char outType);
     void extractItems(const char *filesPath, const char *pattern, char outType);
     void extractItems(const char *filesPath, const Package &listPkg, char outType);
 
     /* This variant extracts an item to a specific filename. */
-    void extractItem(const char *filesPath, const char *outName, int32_t index, char outType);
+    void extractItem(const char *filesPath, const char *outName, int32_t itemIndex, char outType);
 
     int32_t getItemCount() const;
     const Item *getItem(int32_t idx) const;
diff --git a/icu4c/source/tools/toolutil/toolutil.c b/icu4c/source/tools/toolutil/toolutil.c
index 62d1a9565d7..4522104a903 100644
--- a/icu4c/source/tools/toolutil/toolutil.c
+++ b/icu4c/source/tools/toolutil/toolutil.c
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 *
-*   Copyright (C) 1999-2008, International Business Machines
+*   Copyright (C) 1999-2009, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
@@ -152,7 +152,7 @@ uprv_getModificationDate(const char *pathname, UErrorCode *status)
 
 struct UToolMemory {
     char name[64];
-    int32_t capacity, maxCapacity, size, index;
+    int32_t capacity, maxCapacity, size, idx;
     void *array;
     UAlignedMemory staticArray[1];
 };
@@ -176,7 +176,7 @@ utm_open(const char *name, int32_t initialCapacity, int32_t maxCapacity, int32_t
     mem->capacity=initialCapacity;
     mem->maxCapacity=maxCapacity;
     mem->size=size;
-    mem->index=0;
+    mem->idx=0;
     return mem;
 }
 
@@ -198,7 +198,7 @@ utm_getStart(UToolMemory *mem) {
 
 U_CAPI int32_t U_EXPORT2
 utm_countItems(UToolMemory *mem) {
-    return mem->index;
+    return mem->idx;
 }
 
 
@@ -225,7 +225,7 @@ utm_hasCapacity(UToolMemory *mem, int32_t capacity) {
         if(mem->array==mem->staticArray) {
             mem->array=uprv_malloc(newCapacity*mem->size);
             if(mem->array!=NULL) {
-                uprv_memcpy(mem->array, mem->staticArray, mem->index*mem->size);
+                uprv_memcpy(mem->array, mem->staticArray, mem->idx*mem->size);
             }
         } else {
             mem->array=uprv_realloc(mem->array, newCapacity*mem->size);
@@ -242,10 +242,10 @@ utm_hasCapacity(UToolMemory *mem, int32_t capacity) {
 
 U_CAPI void * U_EXPORT2
 utm_alloc(UToolMemory *mem) {
-    char *p=(char *)mem->array+mem->index*mem->size;
-    int32_t newIndex=mem->index+1;
+    char *p=(char *)mem->array+mem->idx*mem->size;
+    int32_t newIndex=mem->idx+1;
     if(utm_hasCapacity(mem, newIndex)) {
-        mem->index=newIndex;
+        mem->idx=newIndex;
         uprv_memset(p, 0, mem->size);
     }
     return p;
@@ -253,10 +253,10 @@ utm_alloc(UToolMemory *mem) {
 
 U_CAPI void * U_EXPORT2
 utm_allocN(UToolMemory *mem, int32_t n) {
-    char *p=(char *)mem->array+mem->index*mem->size;
-    int32_t newIndex=mem->index+n;
+    char *p=(char *)mem->array+mem->idx*mem->size;
+    int32_t newIndex=mem->idx+n;
     if(utm_hasCapacity(mem, newIndex)) {
-        mem->index=newIndex;
+        mem->idx=newIndex;
         uprv_memset(p, 0, n*mem->size);
     }
     return p;
diff --git a/icu4c/source/tools/toolutil/ucm.c b/icu4c/source/tools/toolutil/ucm.c
index bb7c3bb0edd..8d4f33a1790 100644
--- a/icu4c/source/tools/toolutil/ucm.c
+++ b/icu4c/source/tools/toolutil/ucm.c
@@ -1,7 +1,7 @@
 /*
 *******************************************************************************
 *
-*   Copyright (C) 2003-2007, International Business Machines
+*   Copyright (C) 2003-2009, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *
 *******************************************************************************
@@ -915,7 +915,7 @@ ucm_addMapping(UCMTable *table,
                uint8_t bytes[UCNV_EXT_MAX_BYTES]) {
     UCMapping *tm;
     UChar32 c;
-    int32_t index;
+    int32_t idx;
 
     if(table->mappingsLength>=table->mappingsCapacity) {
         /* make the mappings array larger */
@@ -960,32 +960,32 @@ ucm_addMapping(UCMTable *table,
     }
 
     if(m->uLen>1) {
-        index=table->codePointsLength;
+        idx=table->codePointsLength;
         table->codePointsLength+=m->uLen;
         if(table->codePointsLength>table->codePointsCapacity) {
             fprintf(stderr, "ucm error: too many code points in multiple-code point mappings\n");
             exit(U_MEMORY_ALLOCATION_ERROR);
         }
 
-        uprv_memcpy(table->codePoints+index, codePoints, m->uLen*4);
-        m->u=index;
+        uprv_memcpy(table->codePoints+idx, codePoints, m->uLen*4);
+        m->u=idx;
     }
 
     if(m->bLen>4) {
-        index=table->bytesLength;
+        idx=table->bytesLength;
         table->bytesLength+=m->bLen;
         if(table->bytesLength>table->bytesCapacity) {
             fprintf(stderr, "ucm error: too many bytes in mappings with >4 charset bytes\n");
             exit(U_MEMORY_ALLOCATION_ERROR);
         }
 
-        uprv_memcpy(table->bytes+index, bytes, m->bLen);
-        m->b.index=index;
+        uprv_memcpy(table->bytes+idx, bytes, m->bLen);
+        m->b.idx=idx;
     }
 
     /* set unicodeMask */
-    for(index=0; index<m->uLen; ++index) {
-        c=codePoints[index];
+    for(idx=0; idx<m->uLen; ++idx) {
+        c=codePoints[idx];
         if(c>=0x10000) {
             table->unicodeMask|=UCNV_HAS_SUPPLEMENTARY; /* there are supplementary code points */
         } else if(U_IS_SURROGATE(c)) {
diff --git a/icu4c/source/tools/toolutil/ucm.h b/icu4c/source/tools/toolutil/ucm.h
index 6575721175e..6ee13215f2b 100644
--- a/icu4c/source/tools/toolutil/ucm.h
+++ b/icu4c/source/tools/toolutil/ucm.h
@@ -1,6 +1,6 @@
 /*
  *******************************************************************************
- *   Copyright (C) 2003-2007, International Business Machines
+ *   Copyright (C) 2003-2009, International Business Machines
  *   Corporation and others.  All Rights Reserved.
  *******************************************************************************
  *   file name:  ucm.h
@@ -50,7 +50,7 @@ enum {
 typedef struct UCMapping {
     UChar32 u;
     union {
-        uint32_t index;
+        uint32_t idx;
         uint8_t bytes[4];
     } b;
     int8_t uLen, bLen, f, moveFlag;
@@ -111,7 +111,7 @@ typedef struct UCMFile {
     (((m)->uLen==1) ? &(m)->u : (t)->codePoints+(m)->u)
 
 #define UCM_GET_BYTES(t, m) \
-    (((m)->bLen<=4) ? (m)->b.bytes : (t)->bytes+(m)->b.index)
+    (((m)->bLen<=4) ? (m)->b.bytes : (t)->bytes+(m)->b.idx)
 
 /* APIs --------------------------------------------------------------------- */