Replaced occurrences of U_ASSERT(FALSE) with new UPRV_UNREACHABLE macro.
} else if (uprv_strcmp(what, "nfkc_cf") == 0) {
nfkc_cfSingleton = Norm2AllModes::createInstance(NULL, "nfkc_cf", errorCode);
} else {
- U_ASSERT(FALSE); // Unknown singleton
+ UPRV_UNREACHABLE; // Unknown singleton
}
ucln_common_registerCleanup(UCLN_COMMON_LOADED_NORMALIZER2, uprv_loaded_normalizer2_cleanup);
}
case 4:
return ((c&7)<<18) | ((cpStart[1]&0x3f)<<12) | ((cpStart[2]&0x3f)<<6) | (cpStart[3]&0x3f);
default:
- U_ASSERT(FALSE); // Should not occur.
+ UPRV_UNREACHABLE; // Should not occur.
return U_SENTINEL;
}
}
return fPositions[i];
}
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
return -1;
}
}
}
if (i >= kMaxLookaheads) {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
i = kMaxLookaheads - 1;
}
fKeys[i] = key;
return TRUE;
}
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
fPositionInCache = -1;
return FALSE;
}
return TRUE;
}
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
fPositionInCache = -1;
return FALSE;
}
// Add following position(s) to the cache.
while (fBoundaries[fEndBufIdx] < position) {
if (!populateFollowing()) {
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return false;
}
}
break;
default: /* we should never get here */
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
break;
}
}
start2=i;
break;
default: /* we should never get here */
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
break;
}
}
break;
default:
/* we should never get here */
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
break;
}
/*
visualStart+=length;
}
/* we should never get here */
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
*pErrorCode = U_INVALID_STATE_ERROR;
return 0;
}
* WILL NEVER HAPPEN as long as uhash_put() makes sure that
* count is always < length.
*/
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
return NULL; /* Never happens if uhash_put() behaves */
}
return &(elements[theIndex]);
while(length>0) {
u=*us++;
if(!UCHAR_IS_INVARIANT(u)) {
- U_ASSERT(FALSE); /* Variant characters were used. These are not portable in ICU. */
+ UPRV_UNREACHABLE; /* Variant characters were used. These are not portable in ICU. */
u=0;
}
*cs++=(char)UCHAR_TO_CHAR(u);
LocalUResourceBundlePointer typeMapResByKey(ures_getByKey(typeMapRes.getAlias(), legacyKeyId, NULL, &tmpSts));
if (U_FAILURE(tmpSts)) {
// type map for each key must exist
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
} else {
LocalUResourceBundlePointer typeMapEntry;
# define U_FALLTHROUGH
#endif
+/**
+ * \def UPRV_UNREACHABLE
+ * Annotate unreachable code.
+ * https://clang.llvm.org/docs/LanguageExtensions.html#builtin-unreachable
+ * @internal
+*/
+#if defined(UPRV_UNREACHABLE)
+ // Use the predefined value.
+#elif U_DEBUG
+ // Assert on Debug builds to catch if "unreachable" code is reached.
+# define UPRV_UNREACHABLE U_ASSERT(FALSE)
+#elif (defined(__GNUC__) && (U_GCC_MAJOR_MINOR >= 405)) || ( defined(__clang__))
+# define UPRV_UNREACHABLE __builtin_unreachable()
+#elif defined(_MSC_VER)
+# define UPRV_UNREACHABLE __assume(0)
+#else
+# define UPRV_UNREACHABLE U_ASSERT(FALSE)
+#endif
+
/** @} */
/*===========================================================================*/
BreakIterator *WholeStringBreakIterator::clone() const { return nullptr; }
CharacterIterator &WholeStringBreakIterator::getText() const {
- U_ASSERT(FALSE); // really should not be called
+ UPRV_UNREACHABLE; // really should not be called
// Returns a null reference.
// Otherwise we would have to define a dummy CharacterIterator,
// and either have it as a field and const_cast it to a non-const reference,
}
}
void WholeStringBreakIterator::adoptText(CharacterIterator* it) {
- U_ASSERT(FALSE); // should not be called
+ UPRV_UNREACHABLE; // should not be called
length = it->getLength();
delete it;
}
fmt = gExitFmtPtrStatus;
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
fmt = gExitFmt;
}
parserErrorReason = "LDML forbids tailoring to U+FFFF";
return 0;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
return 0;
}
ce32 = encodeOneCE(Collation::unassignedCEFromCodePoint(c), errorCode);
break;
default:
- U_ASSERT(FALSE); // require ce32 == base->getFinalCE32(ce32)
+ UPRV_UNREACHABLE; // require ce32 == base->getFinalCE32(ce32)
break;
}
return ce32;
if (prevElem != nullptr) {
prevElem->next.adoptInstead(curElem);
} else {
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
}
prevElem = curElem;
sType = "islamic-umalqura";
break;
default:
- U_ASSERT(false); // out of range
+ UPRV_UNREACHABLE; // out of range
sType = "islamic"; // "islamic" is used as the generic type
break;
}
month = m;
}
} else { // invalid 'civil'
- U_ASSERT(false); // should not get here, out of range
+ UPRV_UNREACHABLE; // should not get here, out of range
year=month=0;
}
}
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
offset += U16_LENGTH(cp);
case TYPE_CURRENCY_OVERFLOW:
return Field::UNUM_CURRENCY_FIELD;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return Field::UNUM_FIELD_COUNT; // suppress "control reaches end of non-void function"
}
}
return makeTag(offset, TYPE_CURRENCY_OVERFLOW, STATE_BASE, 0);
}
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
}
// End of string
case STATE_OVERFLOW_CURR:
return makeTag(offset, TYPE_CURRENCY_OVERFLOW, STATE_BASE, 0);
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return {-1}; // suppress "control reaches end of non-void function"
}
}
case UNUM_GROUPING_THOUSANDS:
return {3, 3, 1, grouping};
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
return {}; // return a value: silence compiler warning
}
}
bool ConstantAffixModifier::containsField(UNumberFormatFields field) const {
(void)field;
// This method is not currently used.
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return false;
}
void ConstantAffixModifier::getParameters(Parameters& output) const {
(void)output;
// This method is not currently used.
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
bool ConstantAffixModifier::semanticallyEquivalent(const Modifier& other) const {
bool SimpleModifier::containsField(UNumberFormatFields field) const {
(void)field;
// This method is not currently used.
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return false;
}
bool MutablePatternModifier::containsField(UNumberFormatFields field) const {
(void)field;
// This method is not currently used.
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return false;
}
void MutablePatternModifier::getParameters(Parameters& output) const {
(void)output;
// This method is not currently used.
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
bool MutablePatternModifier::semanticallyEquivalent(const Modifier& other) const {
(void)other;
// This method is not currently used.
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return false;
}
case AffixPatternType::TYPE_CURRENCY_QUINT:
return UnicodeString(u"\uFFFD");
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return UnicodeString();
}
}
UnicodeString MutablePatternModifier::toUnicodeString() const {
// Never called by AffixUtils
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return UnicodeString();
}
char16_t ParsedPatternInfo::charAt(int32_t flags, int32_t index) const {
const Endpoints& endpoints = getEndpoints(flags);
if (index < 0 || index >= endpoints.end - endpoints.start) {
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
return pattern.charAt(endpoints.start + index);
}
case Precision::RND_CURRENCY:
// Call .withCurrency() before .apply()!
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
break;
}
}
bool ScientificModifier::containsField(UNumberFormatFields field) const {
(void)field;
// This method is not used for inner modifiers.
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return false;
}
case STEM_NOTATION_SIMPLE:
return Notation::simple();
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return Notation::simple(); // return a value: silence compiler warning
}
}
// Slicing is okay
return NoUnit::permille(); // NOLINT
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return {}; // return a value: silence compiler warning
}
}
case STEM_PRECISION_CURRENCY_CASH:
return Precision::currency(UCURR_USAGE_CASH);
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return Precision::integer(); // return a value: silence compiler warning
}
}
case STEM_ROUNDING_MODE_UNNECESSARY:
return UNUM_ROUND_UNNECESSARY;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return UNUM_ROUND_UNNECESSARY;
}
}
sb.append(u"rounding-mode-unnecessary", -1);
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
}
sb.append(u"group-thousands", -1);
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
}
sb.append(u"unit-width-hidden", -1);
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
}
sb.append(u"sign-accounting-except-zero", -1);
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
}
sb.append(u"decimal-always", -1);
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
}
return STATE_SCALE;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return STATE_NULL; // return a value: silence compiler warning
}
}
break;
default:
patternKey = "decimalFormat"; // silence compiler error
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
}
LocalUResourceBundlePointer res(ures_open(nullptr, locale.getName(), &status));
if (U_FAILURE(status)) { return u""; }
addMatcher(fWarehouse.currency(status));
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
} else if (fIgnorables != nullptr && fIgnorables->getSet()->contains(cp)) {
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
break;
}
}
case tVariableT:
return PLURAL_OPERAND_T;
default:
- U_ASSERT(FALSE); // unexpected.
+ UPRV_UNREACHABLE; // unexpected.
return PLURAL_OPERAND_N;
}
}
case PLURAL_OPERAND_T: return static_cast<double>(decimalDigitsWithoutTrailingZeros);
case PLURAL_OPERAND_V: return visibleDecimalDigitCount;
default:
- U_ASSERT(FALSE); // unexpected.
+ UPRV_UNREACHABLE; // unexpected.
return source;
}
}
case 0x78: /* 'x' */ bit = UREGEX_COMMENTS; break;
case 0x2d: /* '-' */ fSetModeFlag = FALSE; break;
default:
- U_ASSERT(FALSE); // Should never happen. Other chars are filtered out
+ UPRV_UNREACHABLE; // Should never happen. Other chars are filtered out
// by the scanner.
}
if (fSetModeFlag) {
}
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
error(U_REGEX_INTERNAL_ERROR);
break;
}
return 0;
}
if (type < 0 || type > 255) {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
error(U_REGEX_INTERNAL_ERROR);
type = URX_RESERVED_OP;
}
if (val > 0x00ffffff) {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
error(U_REGEX_INTERNAL_ERROR);
val = 0;
}
if (val < 0) {
if (!(type == URX_RESERVED_OP_N || type == URX_RESERVED_OP)) {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
error(U_REGEX_INTERNAL_ERROR);
return -1;
}
if (URX_TYPE(val) != 0xff) {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
error(U_REGEX_INTERNAL_ERROR);
return -1;
}
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
// remember the next location in the compiled pattern.
if (c < UCHAR_MIN_VALUE || c > UCHAR_MAX_VALUE) {
// This function should never be called with an invalid input character.
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
starterChars->clear();
} else if (u_hasBinaryProperty(c, UCHAR_CASE_SENSITIVE)) {
UChar32 caseFoldedC = u_foldCase(c, U_FOLD_CASE_DEFAULT);
case URX_LB_END:
case URX_LBN_CONT:
case URX_LBN_END:
- U_ASSERT(FALSE); // Shouldn't get here. These ops should be
+ UPRV_UNREACHABLE; // Shouldn't get here. These ops should be
// consumed by the scan in URX_LA_START and LB_START
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
}
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
}
case URX_CTR_LOOP_NG:
// These opcodes will be skipped over by code for URX_CRT_INIT.
// We shouldn't encounter them here.
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
break;
case URX_LOOP_SR_I:
// End of look-ahead ops should always be consumed by the processing at
// the URX_LA_START op.
- // U_ASSERT(FALSE);
+ // UPRV_UNREACHABLE;
// break;
case URX_LB_START:
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
default:
// Some op is unaccounted for.
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
error(U_REGEX_INTERNAL_ERROR);
}
}
delete rightOperand;
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
break;
}
}
if (findProgressInterrupt(startPos, status))
return FALSE;
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
case START_START:
// Matches are only possible at the start of the input string
return FALSE;
}
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
case START_STRING:
case START_CHAR:
return FALSE;
}
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
case START_LINE:
{
}
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
return FALSE;
}
if (findProgressInterrupt(startPos, status))
return FALSE;
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
case START_START:
// Matches are only possible at the start of the input string
return FALSE;
}
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
case START_STRING:
case START_CHAR:
return FALSE;
}
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
case START_LINE:
{
}
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
return FALSE;
}
default:
// Trouble. The compiled pattern contains an entry with an
// unrecognized type tag.
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
if (U_FAILURE(status)) {
default:
// Trouble. The compiled pattern contains an entry with an
// unrecognized type tag.
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
if (U_FAILURE(status)) {
}
}
else {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
}
appendTo += zoneString;
tzfmt->format(UTZFMT_STYLE_GENERIC_SHORT, *this, date, result, &timeType);
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
// Generic format many use Localized GMT as the final fallback.
// When Localized GMT format is used, the result might not be
tzfmt->formatOffsetISO8601Basic(offset, FALSE, FALSE, FALSE, result, status);
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
} else {
nameType = daylight ? UTZNM_SHORT_DAYLIGHT : UTZNM_SHORT_STANDARD;
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
LocalPointer<TimeZoneNames> tznames(TimeZoneNames::createInstance(locale, status));
if (U_FAILURE(status)) {
initTime("second");
break;
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
break;
}
}
}
break;
case RULES:
- U_ASSERT(FALSE); // don't call create() if isRuleBased() returns TRUE!
+ UPRV_UNREACHABLE; // don't call create() if isRuleBased() returns TRUE!
break;
}
return t;
}
return 0;
default:
- U_ASSERT(FALSE); // can't get here
+ UPRV_UNREACHABLE; // can't get here
return 0;
}
}
case SECOND:
return (width == 2);
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
return (width > 0);
}
required = FIELDS_HMS;
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
break;
}
break;
default:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
}
int32_t len = 0;
default:
// Unknown/unsupported argument type.
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
*status=U_ILLEGAL_ARGUMENT_ERROR;
break;
}
// support kObject. When MessageFormat is changed to
// understand MeasureFormats, modify this code to do the
// right thing. [alan]
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
break;
// better not happen!
case Formattable::kArray:
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
break;
}
}
// Verify that it is the next one in sequence, which is all
// that is allowed.
if (index != limitIx) {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
return NULL;
}
// Verify that it is the next one in sequence, which is all
// that is allowed.
if (index != limitIx) {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
return NULL;
}
return NULL;
}
if (!fDataOwned) {
- U_ASSERT(FALSE);
+ UPRV_UNREACHABLE;
status = U_INTERNAL_PROGRAM_ERROR;
return NULL;
}
log_err("u_charsToUChars(variantChars) failed\n");
}
-#ifdef NDEBUG
+#ifndef U_DEBUG
/*
* Test u_UCharsToChars(variantUChars) only in release mode because it will
* cause an assertion failure in debug builds.
case TYPE_CURRENCY_OVERFLOW:
return u"\uFFFD";
default:
- U_ASSERT(false);
+ UPRV_UNREACHABLE;
return {}; // silence compiler warnings
}
}
projects / icu / commitdiff