organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-06 14:05:32 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 8

ICU-4288 Mostly fixes for --enable-strict for gcc 3.4 (Fedora Core 3)

Browse source 
X-SVN-Rev: 17040
This commit is contained in:
George Rhoten 2004-12-30 07:25:51 +00:00
parent 8ed12212b4
commit 4b8ef3e6e6
18 changed files with 128 additions and 130 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
icu4c/source/aclocal.m4 vendored
View file

@ -267,7 +267,7 @@ AC_DEFUN(AC_CHECK_STRICT_COMPILE,
fi
if test "$GXX" = yes
then
CXXFLAGS="$CXXFLAGS -W -Wall -ansi -pedantic -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -Winline -Wno-long-long"
CXXFLAGS="$CXXFLAGS -W -Wall -ansi -pedantic -Wpointer-arith -Wwrite-strings -Winline -Wno-long-long"
case "${host}" in
*-*-solaris*)
CXXFLAGS="$CXXFLAGS -D__STDC__=0";;

2
icu4c/source/common/uvectr32.h
View file

@ -264,7 +264,7 @@ inline UBool UVector32::operator!=(const UVector32& other) {
inline int32_t *UVector32::getBuffer() const {
return elements;
};
}
// UStack inlines

2
icu4c/source/configure vendored
View file

@ -1322,7 +1322,7 @@ fi
fi
if test "$GXX" = yes
then
CXXFLAGS="$CXXFLAGS -W -Wall -ansi -pedantic -Wpointer-arith -Wmissing-prototypes -Wwrite-strings -Winline -Wno-long-long"
CXXFLAGS="$CXXFLAGS -W -Wall -ansi -pedantic -Wpointer-arith -Wwrite-strings -Winline -Wno-long-long"
case "${host}" in
*-*-solaris*)
CXXFLAGS="$CXXFLAGS -D__STDC__=0";;

2
icu4c/source/i18n/gregoimp.cpp
View file

@ -264,7 +264,7 @@ UResourceBundle* CalendarData::getByKey2(const char *key, const char *subKey, UE
return fFillin;
}
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CalendarData);
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(CalendarData)
#endif
//eof

2
icu4c/source/i18n/hebrwcal.cpp
View file

@ -721,7 +721,7 @@ HebrewCalendar::initializeSystemDefaultCentury()
}
}
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HebrewCalendar);
UOBJECT_DEFINE_RTTI_IMPLEMENTATION(HebrewCalendar)
U_NAMESPACE_END

77
icu4c/source/i18n/regexcmp.cpp
View file

@ -43,11 +43,11 @@ U_NAMESPACE_BEGIN
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Constructor.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
RegexCompile::RegexCompile(RegexPattern *rxp, UErrorCode &status) : fParenStack(status)
{
fStatus = &status;
@ -74,22 +74,22 @@ RegexCompile::RegexCompile(RegexPattern *rxp, UErrorCode &status) : fParenStack(
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Destructor
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
RegexCompile::~RegexCompile() {
}
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Compile regex pattern. The state machine for rexexp pattern parsing is here.
// The state tables are hand-written in the file regexcst.txt,
// and converted to the form used here by a perl
// script regexcst.pl
//
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::compile(
const UnicodeString &pat, // Source pat to be compiled.
UParseError &pp, // Error position info
@ -311,7 +311,7 @@ void RegexCompile::compile(
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// doParseAction Do some action during regex pattern parsing.
// Called by the parse state machine.
@ -320,7 +320,7 @@ void RegexCompile::compile(
// in functions called from the parse actions defined here.
//
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
UBool RegexCompile::doParseActions(EParseAction action)
{
UBool returnVal = TRUE;
@ -1391,7 +1391,7 @@ UBool RegexCompile::doParseActions(EParseAction action)
}
return returnVal;
};
}
@ -1691,7 +1691,7 @@ int32_t RegexCompile::blockTopLoc(UBool reserveLoc) {
// This function is called both when encountering a
// real ) and at the end of the pattern.
//
//-------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::handleCloseParen() {
int32_t patIdx;
int32_t patOp;
@ -1877,12 +1877,12 @@ void RegexCompile::handleCloseParen() {
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// compileSet Compile the pattern operations for a reference to a
// UnicodeSet.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::compileSet(UnicodeSet *theSet)
{
if (theSet == NULL) {
@ -1929,7 +1929,7 @@ void RegexCompile::compileSet(UnicodeSet *theSet)
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// compileInterval Generate the code for a {min, max} style interval quantifier.
// Except for the specific opcodes used, the code is the same
@ -1945,7 +1945,7 @@ void RegexCompile::compileSet(UnicodeSet *theSet)
// 5 CTR_LOOP
//
// In
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::compileInterval(int32_t InitOp, int32_t LoopOp)
{
// The CTR_INIT op at the top of the block with the {n,m} quantifier takes
@ -2049,7 +2049,7 @@ UBool RegexCompile::compileInlineInterval() {
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// matchStartType Determine how a match can start.
// Used to optimize find() operations.
@ -2059,7 +2059,7 @@ UBool RegexCompile::compileInlineInterval() {
// op where the min match coming in is zero, add that ops possible
// starting matches to the possible starts for the overall pattern.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::matchStartType() {
if (U_FAILURE(*fStatus)) {
return;
@ -2519,7 +2519,7 @@ void RegexCompile::matchStartType() {
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// minMatchLength Calculate the length of the shortest string that could
// match the specified pattern.
@ -2532,7 +2532,7 @@ void RegexCompile::matchStartType() {
// start and end are the range of p-code operations to be
// examined. The endpoints are included in the range.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int32_t RegexCompile::minMatchLength(int32_t start, int32_t end) {
if (U_FAILURE(*fStatus)) {
return 0;
@ -2771,7 +2771,7 @@ int32_t RegexCompile::minMatchLength(int32_t start, int32_t end) {
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// maxMatchLength Calculate the length of the longest string that could
// match the specified pattern.
@ -2781,7 +2781,7 @@ int32_t RegexCompile::minMatchLength(int32_t start, int32_t end) {
// value may be longer than the actual maximum; it must
// never be shorter.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int32_t RegexCompile::maxMatchLength(int32_t start, int32_t end) {
if (U_FAILURE(*fStatus)) {
return 0;
@ -3000,14 +3000,14 @@ int32_t RegexCompile::maxMatchLength(int32_t start, int32_t end) {
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// stripNOPs Remove any NOP operations from the compiled pattern code.
// Extra NOPs are inserted for some constructs during the initial
// code generation to provide locations that may be patched later.
// Many end up unneeded, and are removed by this function.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::stripNOPs() {
if (U_FAILURE(*fStatus)) {
@ -3125,7 +3125,7 @@ void RegexCompile::stripNOPs() {
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// OptDotStar Optimize patterns that end with a '.*' or '.+' to
// just advance the input to the end.
@ -3142,7 +3142,7 @@ void RegexCompile::stripNOPs() {
// [NOP | END_CAPTURE | DOLLAR | BACKSLASH_Z]*
// END
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::OptDotStar() {
// Scan backwards in the pattern, looking for a JMP_SAV near the end.
int32_t jmpLoc;
@ -3202,12 +3202,12 @@ void RegexCompile::OptDotStar() {
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Error Report a rule parse error.
// Only report it if no previous error has been recorded.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::error(UErrorCode e) {
if (U_SUCCESS(*fStatus)) {
*fStatus = e;
@ -3249,13 +3249,13 @@ static const UChar chLowerP = 0x70;
static const UChar chUpperP = 0x50;
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// nextCharLL Low Level Next Char from the regex pattern.
// Get a char from the string, keep track of input position
// for error reporting.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
UChar32 RegexCompile::nextCharLL() {
UChar32 ch;
UnicodeString &pattern = fRXPat->fPattern;
@ -3295,12 +3295,12 @@ UChar32 RegexCompile::nextCharLL() {
return ch;
}
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// peekCharLL Low Level Character Scanning, sneak a peek at the next
// character without actually getting it.
//
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
UChar32 RegexCompile::peekCharLL() {
if (fPeekChar == -1) {
fPeekChar = nextCharLL();
@ -3309,13 +3309,13 @@ UChar32 RegexCompile::peekCharLL() {
}
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// nextChar for pattern scanning. At this level, we handle stripping
// out comments and processing some backslash character escapes.
// The rest of the pattern grammar is handled at the next level up.
//
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
void RegexCompile::nextChar(RegexPatternChar &c) {
fScanIndex = fNextIndex;
@ -3411,7 +3411,7 @@ void RegexCompile::nextChar(RegexPatternChar &c) {
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// scanSet Construct a UnicodeSet from the text at the current scan
// position. Advance the scan position to the first character
@ -3421,7 +3421,7 @@ void RegexCompile::nextChar(RegexPatternChar &c) {
// that controls pattern parsing. UnicodeSets, however, are parsed by
// the UnicodeSet constructor, not by the Regex pattern parser.
//
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
UnicodeSet *RegexCompile::scanSet() {
UnicodeSet *uset = NULL;
ParsePosition pos;
@ -3466,10 +3466,10 @@ UnicodeSet *RegexCompile::scanSet() {
}
return uset;
};
}
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// scanProp Construct a UnicodeSet from the text at the current scan
// position, which will be of the form \p{whaterver}
@ -3480,7 +3480,7 @@ UnicodeSet *RegexCompile::scanSet() {
// Return a UnicodeSet, constructed from the \P pattern,
// or NULL if the pattern is invalid.
//
//---------------------------------------------------------------------------------
//------------------------------------------------------------------------------
UnicodeSet *RegexCompile::scanProp() {
UnicodeSet *uset = NULL;
@ -3525,7 +3525,8 @@ UnicodeSet *RegexCompile::scanProp() {
nextChar(fC); // Continue overall regex pattern processing with char after the '}'
return uset;
};
}
U_NAMESPACE_END
#endif // !UCONFIG_NO_REGULAR_EXPRESSIONS

4
icu4c/source/i18n/regeximp.h
View file

@ -318,11 +318,11 @@ inline Regex8BitSet::Regex8BitSet() {
inline UBool Regex8BitSet::contains(UChar32 c) {
// No bounds checking! This is deliberate.
return ((d[c>>3] & 1 <<(c&7)) != 0);
};
}
inline void Regex8BitSet::add(UChar32 c) {
d[c>>3] |= 1 << (c&7);
};
}
inline void Regex8BitSet::init(const UnicodeSet *s) {
if (s != NULL) {

12
icu4c/source/i18n/repattrn.cpp
View file

@ -36,7 +36,7 @@ RegexPattern::RegexPattern() {
// Lazy init of all shared global sets.
RegexStaticSets::initGlobals(&fDeferredStatus);
};
}
//--------------------------------------------------------------------------
@ -200,7 +200,7 @@ void RegexPattern::zap() {
//--------------------------------------------------------------------------
RegexPattern::~RegexPattern() {
zap();
};
}
//--------------------------------------------------------------------------
@ -211,7 +211,7 @@ RegexPattern::~RegexPattern() {
RegexPattern *RegexPattern::clone() const {
RegexPattern *copy = new RegexPattern(*this);
return copy;
};
}
//--------------------------------------------------------------------------
@ -271,7 +271,7 @@ RegexPattern::compile(const UnicodeString &regex,
compiler.compile(regex, pe, status);
return This;
};
}
//
// compile with default flags.
@ -322,7 +322,7 @@ RegexMatcher *RegexPattern::matcher(const UnicodeString &input,
retMatcher->reset(input);
}
return retMatcher;
};
}
RegexMatcher *RegexPattern::matcher(const UChar * /*input*/,
UErrorCode &status) const
@ -357,7 +357,7 @@ RegexMatcher *RegexPattern::matcher(UErrorCode &status) const {
return NULL;
}
return retMatcher;
};
}

4
icu4c/source/i18n/ucol.cpp
View file

@ -7324,7 +7324,7 @@ static
inline void UCOL_INIT_CEBUF(ucol_CEBuf *b) {
(b)->buf = (b)->pos = (b)->localArray;
(b)->endp = (b)->buf + UCOL_CEBUF_SIZE;
};
}
static
void ucol_CEBuf_Expand(ucol_CEBuf *b, collIterate *ci) {
@ -7353,7 +7353,7 @@ inline void UCOL_CEBUF_PUT(ucol_CEBuf *b, uint32_t ce, collIterate *ci) {
ucol_CEBuf_Expand(b, ci);
}
*(b)->pos++ = ce;
};
}
/* This is a trick string compare function that goes in and uses sortkeys to compare */
/* It is used when compare gets in trouble and needs to bail out */

115
icu4c/source/i18n/uregex.cpp
View file

@ -209,16 +209,16 @@ uregex_clone(const URegularExpression *source, UErrorCode *status) {
// Note: fText is not cloned.
return clone;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_pattern
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI const UChar * U_EXPORT2
uregex_pattern(const URegularExpression *regexp,
int32_t *patLength,
@ -231,14 +231,14 @@ uregex_pattern(const URegularExpression *regexp,
*patLength = regexp->fPatStringLen;
}
return regexp->fPatString;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_flags
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI int32_t U_EXPORT2
uregex_flags(const URegularExpression *regexp, UErrorCode *status) {
if (validateRE(regexp, status, FALSE) == FALSE) {
@ -246,14 +246,14 @@ uregex_flags(const URegularExpression *regexp, UErrorCode *status) {
}
int32_t flags = regexp->fPat->flags();
return flags;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_setText
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI void U_EXPORT2
uregex_setText(URegularExpression *regexp,
const UChar *text,
@ -272,15 +272,15 @@ uregex_setText(URegularExpression *regexp,
regexp->fTextString.setTo(isTerminated, text, textLength);
regexp->fMatcher->reset(regexp->fTextString);
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_getText
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI const UChar * U_EXPORT2
uregex_getText(URegularExpression *regexp,
int32_t *textLength,
@ -292,14 +292,14 @@ uregex_getText(URegularExpression *regexp,
*textLength = regexp->fTextLength;
}
return regexp->fText;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_matches
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI UBool U_EXPORT2
uregex_matches(URegularExpression *regexp,
int32_t startIndex,
@ -309,15 +309,15 @@ uregex_matches(URegularExpression *regexp,
}
UBool result = regexp->fMatcher->matches(startIndex, *status);
return result;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_lookingAt
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI UBool U_EXPORT2
uregex_lookingAt(URegularExpression *regexp,
int32_t startIndex,
@ -327,15 +327,15 @@ uregex_lookingAt(URegularExpression *regexp,
}
UBool result = regexp->fMatcher->lookingAt(startIndex, *status);
return result;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_find
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI UBool U_EXPORT2
uregex_find(URegularExpression *regexp,
int32_t startIndex,
@ -345,13 +345,13 @@ uregex_find(URegularExpression *regexp,
}
UBool result = regexp->fMatcher->find(startIndex, *status);
return result;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_findNext
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI UBool U_EXPORT2
uregex_findNext(URegularExpression *regexp,
UErrorCode *status) {
@ -360,13 +360,13 @@ uregex_findNext(URegularExpression *regexp,
}
UBool result = regexp->fMatcher->find();
return result;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_groupCount
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI int32_t U_EXPORT2
uregex_groupCount(URegularExpression *regexp,
UErrorCode *status) {
@ -375,14 +375,14 @@ uregex_groupCount(URegularExpression *regexp,
}
int32_t result = regexp->fMatcher->groupCount();
return result;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_group
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI int32_t U_EXPORT2
uregex_group(URegularExpression *regexp,
int32_t groupNum,
@ -427,14 +427,14 @@ uregex_group(URegularExpression *regexp,
u_memcpy(dest, &regexp->fText[startIx], copyLength);
}
return fullLength;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_start
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI int32_t U_EXPORT2
uregex_start(URegularExpression *regexp,
int32_t groupNum,
@ -444,14 +444,14 @@ uregex_start(URegularExpression *regexp,
}
int32_t result = regexp->fMatcher->start(groupNum, *status);
return result;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_end
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI int32_t U_EXPORT2
uregex_end(URegularExpression *regexp,
int32_t groupNum,
@ -461,13 +461,13 @@ uregex_end(URegularExpression *regexp,
}
int32_t result = regexp->fMatcher->end(groupNum, *status);
return result;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_reset
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI void U_EXPORT2
uregex_reset(URegularExpression *regexp,
int32_t index,
@ -476,14 +476,14 @@ uregex_reset(URegularExpression *regexp,
return;
}
regexp->fMatcher->reset(index, *status);
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_replaceAll
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI int32_t U_EXPORT2
uregex_replaceAll(URegularExpression *regexp,
UChar *replacementText,
@ -510,14 +510,14 @@ uregex_replaceAll(URegularExpression *regexp,
len += uregex_appendTail(regexp, &destBuf, &destCapacity, status);
return len;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_replaceFirst
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI int32_t U_EXPORT2
uregex_replaceFirst(URegularExpression *regexp,
UChar *replacementText,
@ -546,14 +546,14 @@ uregex_replaceFirst(URegularExpression *regexp,
len += uregex_appendTail(regexp, &destBuf, &destCapacity, status);
return len;
};
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_appendReplacement
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
@ -820,11 +820,11 @@ uregex_appendReplacement(URegularExpression *regexp,
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_appendTail
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
int32_t RegexCImpl::appendTail(URegularExpression *regexp,
UChar **destBuf,
int32_t *destCapacity,
@ -922,7 +922,7 @@ int32_t RegexCImpl::appendTail(URegularExpression *regexp,
}
return destIdx;
};
}
U_CAPI int32_t U_EXPORT2
@ -934,14 +934,14 @@ uregex_appendTail(URegularExpression *regexp,
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// copyString Internal utility to copy a string to an output buffer,
// while managing buffer overflow and preflight size
// computation. NUL termination is added to destination,
// and the NUL is counted in the output size.
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
static void copyString(UChar *destBuffer, // Destination buffer.
int32_t destCapacity, // Total capacity of dest buffer
int32_t *destIndex, // Index into dest buffer. Updated on return.
@ -968,11 +968,11 @@ static void copyString(UChar *destBuffer, // Destination buffer.
}
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// uregex_split
//
//----------------------------------------------------------------------------------------
//------------------------------------------------------------------------------
U_CAPI int32_t U_EXPORT2
uregex_split( URegularExpression *regexp,
UChar *destBuf,
@ -1098,8 +1098,5 @@ uregex_split( URegularExpression *regexp,
}
#endif // !UCONFIG_NO_REGULAR_EXPRESSIONS

2
icu4c/source/layout/LayoutEngine.cpp
View file

@ -123,7 +123,7 @@ LayoutEngine::LayoutEngine(const LEFontInstance *fontInstance, le_int32 scriptCo
le_int32 LayoutEngine::getGlyphCount() const
{
return fGlyphStorage->getGlyphCount();
};
}
void LayoutEngine::getCharIndices(le_int32 charIndices[], le_int32 indexBase, LEErrorCode &success) const
{

2
icu4c/source/layout/LookupProcessor.cpp
View file

@ -224,6 +224,6 @@ LookupProcessor::~LookupProcessor()
{
LE_DELETE_ARRAY(lookupOrderArray);
LE_DELETE_ARRAY(lookupSelectArray);
};
}
U_NAMESPACE_END

10
icu4c/source/test/intltest/rbbitst.cpp
View file

@ -72,7 +72,7 @@ BITestData::BITestData(UErrorCode &status)
: fExpectedBreakPositions(status), fExpectedTags(status), fLineNum(status), fActualBreakPositions(status),
fActualTags(status)
{
};
}
//
// addDataChunk. Add a section (non-breaking) piece if data to the test data.
@ -92,7 +92,7 @@ void BITestData::addDataChunk(const char *data, int32_t tag, int32_t lineNum, UE
fExpectedBreakPositions.addElement(fDataToBreak.length(), status);
fExpectedTags.addElement(tag, status);
fLineNum.addElement(lineNum, status);
};
}
//
@ -1987,7 +1987,7 @@ RBBICharMonkey::RBBICharMonkey() {
if (U_FAILURE(status)) {
deferredStatus = status;
}
};
}
void RBBICharMonkey::setText(const UnicodeString &s) {
@ -2111,7 +2111,7 @@ RBBIWordMonkey::RBBIWordMonkey() : fGCFMatcher(0),
if (U_FAILURE(status)) {
deferredStatus = status;
}
};
}
void RBBIWordMonkey::setText(const UnicodeString &s) {
fText = &s;
@ -2440,7 +2440,7 @@ RBBILineMonkey::RBBILineMonkey()
if (U_FAILURE(status)) {
deferredStatus = status;
}
};
}
void RBBILineMonkey::setText(const UnicodeString &s) {

2
icu4c/source/test/intltest/regcoll.cpp
View file

@ -359,7 +359,7 @@ void CollationRegressionTest::Test4060154(/* char* par */)
compareArray(*c, secondary, ARRAY_LENGTH(secondary));
delete c;
};
}
// @bug 4062418
//

6
icu4c/source/test/intltest/regextst.cpp
View file

@ -31,12 +31,12 @@
//---------------------------------------------------------------------------
RegexTest::RegexTest()
{
};
}
RegexTest::~RegexTest()
{
};
}
@ -568,7 +568,7 @@ void RegexTest::Basic() {
REGEX_TESTLM("\\\\\\|\\(\\)\\[\\{\\~\\$\\*\\+\\?\\.", "\\\\|()[{~$*+?.", TRUE, TRUE);
};
}
//---------------------------------------------------------------------------

2
icu4c/source/test/intltest/tsmthred.cpp
View file

@ -849,7 +849,7 @@ void formatErrorMessage(UErrorCode &realStatus, const UnicodeString& pattern, co
fmt->format(myArgs,4,result,ignore,realStatus);
delete fmt;
};
}
UBool U_CALLCONV isAcceptable(void *, const char *, const char *, const UDataInfo *) {

6
icu4c/source/test/intltest/uvectest.cpp
View file

@ -21,12 +21,12 @@
//---------------------------------------------------------------------------
UVectorTest::UVectorTest()
{
};
}
UVectorTest::~UVectorTest()
{
};
}
@ -115,7 +115,7 @@ void UVectorTest::UVector_API() {
TEST_ASSERT(a->elementAti(2) == 20);
TEST_ASSERT(a->elementAti(3) == 30);
delete a;
};
}
void UVectorTest::UStack_API() {
UErrorCode status = U_ZERO_ERROR;

6
icu4c/source/test/intltest/v32test.cpp
View file

@ -27,12 +27,12 @@
//---------------------------------------------------------------------------
UVector32Test::UVector32Test()
{
};
}
UVector32Test::~UVector32Test()
{
};
}
@ -490,6 +490,6 @@ void UVector32Test::UVector32_API() {
TEST_CHECK_STATUS(status);
delete a;
};
}