organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-13 00:43:32 +00:00
Code Issues1 Projects Releases Wiki Activity Actions2

ICU-6799 more warning fixes

Browse source 
X-SVN-Rev: 25722
This commit is contained in:
Steven R. Loomis 2009-04-02 07:34:37 +00:00
parent 3fbe15ba2d
commit 99283aed44
7 changed files with 96 additions and 96 deletions

8
icu4c/source/i18n/cpdtrans.h
View file

@ -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:

38
icu4c/source/tools/makeconv/genmbcs.c
View file

@ -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;

90
icu4c/source/tools/toolutil/package.cpp
View file

@ -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);
}
}

8
icu4c/source/tools/toolutil/package.h
View file

@ -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;

22
icu4c/source/tools/toolutil/toolutil.c
View file

@ -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;

20
icu4c/source/tools/toolutil/ucm.c
View file

@ -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)) {

6
icu4c/source/tools/toolutil/ucm.h
View file

@ -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 --------------------------------------------------------------------- */