Get ICU 4.6 to be compiled without RTTI....

third_party/icu/source/i18n/unum.cpp

 /*
 *******************************************************************************
 *   Copyright (C) 1996-2010, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 * Modification History:
 *
 *   Date        Name        Description
 *   06/24/99    helena      Integrated Alan's NF enhancements and Java2 bug fixes
 *******************************************************************************
@@ skipping 150 matching lines @@
 
 U_CAPI UNumberFormat* U_EXPORT2
 unum_clone(const UNumberFormat *fmt,
        UErrorCode *status)
 {
     if(U_FAILURE(*status))
         return 0;
     
     Format *res = 0;
     const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
-    const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
+    const DecimalFormat* df = CR_DYNAMIC_CAST<const DecimalFormat*>(nf);
     if (df != NULL) {
         res = df->clone();
     } else {
-        const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
+        const RuleBasedNumberFormat* rbnf = CR_DYNAMIC_CAST<const RuleBasedNumberFormat*>(nf);
         U_ASSERT(rbnf != NULL);
         res = rbnf->clone();
     }
 
     if(res == 0) {
         *status = U_MEMORY_ALLOCATION_ERROR;
         return 0;
     }
     
     return (UNumberFormat*) res;
@@ skipping 267 matching lines @@
                          const UChar* text,
                          int32_t textLength,
                          int32_t* parsePos, /* 0 = start */
                          UChar* currency,
                          UErrorCode* status) {
     Formattable res;
     parseRes(res, fmt, text, textLength, parsePos, TRUE, status);
     currency[0] = 0;
     const CurrencyAmount* c;
     if (res.getType() == Formattable::kObject &&
-        (c = dynamic_cast<const CurrencyAmount*>(res.getObject())) != NULL) {
+        (c = CR_DYNAMIC_CAST<const CurrencyAmount*>(res.getObject())) != NULL) {
         u_strcpy(currency, c->getISOCurrency());
     }
     return res.getDouble(*status);
 }
 
 U_CAPI const char* U_EXPORT2
 unum_getAvailable(int32_t index)
 {
     return uloc_getAvailable(index);
 }
 
 U_CAPI int32_t U_EXPORT2
 unum_countAvailable()
 {
     return uloc_countAvailable();
 }
 
 U_CAPI int32_t U_EXPORT2
 unum_getAttribute(const UNumberFormat*          fmt,
           UNumberFormatAttribute  attr)
 {
   const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
-  const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
+  const DecimalFormat* df = CR_DYNAMIC_CAST<const DecimalFormat*>(nf);
   if (df != NULL) {
     switch(attr) {
     case UNUM_PARSE_INT_ONLY:
         return df->isParseIntegerOnly();
         
     case UNUM_GROUPING_USED:
         return df->isGroupingUsed();
         
     case UNUM_DECIMAL_ALWAYS_SHOWN:
         return df->isDecimalSeparatorAlwaysShown();    
@@ skipping 43 matching lines @@
         return df->getPadPosition();
         
     case UNUM_SECONDARY_GROUPING_SIZE:
         return df->getSecondaryGroupingSize();
         
     default:
         /* enums out of sync? unsupported enum? */
         break;
     }
   } else {
-    const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
+    const RuleBasedNumberFormat* rbnf = CR_DYNAMIC_CAST<const RuleBasedNumberFormat*>(nf);
     U_ASSERT(rbnf != NULL);
     if (attr == UNUM_LENIENT_PARSE) {
 #if !UCONFIG_NO_COLLATION
       return rbnf->isLenient();
 #endif
     }
   }
 
   return -1;
 }
 
 U_CAPI void U_EXPORT2
 unum_setAttribute(    UNumberFormat*          fmt,
             UNumberFormatAttribute  attr,
             int32_t                 newValue)
 {
   NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
-  DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
+  DecimalFormat* df = CR_DYNAMIC_CAST<DecimalFormat*>(nf);
   if (df != NULL) {
     switch(attr) {
     case UNUM_PARSE_INT_ONLY:
         df->setParseIntegerOnly(newValue!=0);
         break;
         
     case UNUM_GROUPING_USED:
         df->setGroupingUsed(newValue!=0);
         break;
         
@@ skipping 62 matching lines @@
         
     case UNUM_SECONDARY_GROUPING_SIZE:
         df->setSecondaryGroupingSize(newValue);
         break;
         
     default:
         /* Shouldn't get here anyway */
         break;
     }
   } else {
-    RuleBasedNumberFormat* rbnf = dynamic_cast<RuleBasedNumberFormat*>(nf);
+    RuleBasedNumberFormat* rbnf = CR_DYNAMIC_CAST<RuleBasedNumberFormat*>(nf);
     U_ASSERT(rbnf != NULL);
     if (attr == UNUM_LENIENT_PARSE) {
 #if !UCONFIG_NO_COLLATION
       rbnf->setLenient((UBool)newValue);
 #endif
     }
   }
 }
 
 U_CAPI double U_EXPORT2
 unum_getDoubleAttribute(const UNumberFormat*          fmt,
           UNumberFormatAttribute  attr)
 {
     const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
-    const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
+    const DecimalFormat* df = CR_DYNAMIC_CAST<const DecimalFormat*>(nf);
     if (df != NULL &&  attr == UNUM_ROUNDING_INCREMENT) {
         return df->getRoundingIncrement();
     } else {
         return -1.0;
     }
 }
 
 U_CAPI void U_EXPORT2
 unum_setDoubleAttribute(    UNumberFormat*          fmt,
             UNumberFormatAttribute  attr,
             double                 newValue)
 {
     NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
-    DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
+    DecimalFormat* df = CR_DYNAMIC_CAST<DecimalFormat*>(nf);
     if (df != NULL && attr == UNUM_ROUNDING_INCREMENT) {   
         df->setRoundingIncrement(newValue);
     }
 }
 
 U_CAPI int32_t U_EXPORT2
 unum_getTextAttribute(const UNumberFormat*  fmt,
             UNumberFormatTextAttribute      tag,
             UChar*                          result,
             int32_t                         resultLength,
             UErrorCode*                     status)
 {
     if(U_FAILURE(*status))
         return -1;
 
     UnicodeString res;
     if(!(result==NULL && resultLength==0)) {
         // NULL destination for pure preflighting: empty dummy string
         // otherwise, alias the destination buffer
         res.setTo(result, 0, resultLength);
     }
 
     const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
-    const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
+    const DecimalFormat* df = CR_DYNAMIC_CAST<const DecimalFormat*>(nf);
     if (df != NULL) {
         switch(tag) {
         case UNUM_POSITIVE_PREFIX:
             df->getPositivePrefix(res);
             break;
 
         case UNUM_POSITIVE_SUFFIX:
             df->getPositiveSuffix(res);
             break;
 
@@ skipping 11 matching lines @@
 
         case UNUM_CURRENCY_CODE:
             res = UnicodeString(df->getCurrency());
             break;
 
         default:
             *status = U_UNSUPPORTED_ERROR;
             return -1;
         }
     } else {
-        const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
+        const RuleBasedNumberFormat* rbnf = CR_DYNAMIC_CAST<const RuleBasedNumberFormat*>(nf);
         U_ASSERT(rbnf != NULL);
         if (tag == UNUM_DEFAULT_RULESET) {
             res = rbnf->getDefaultRuleSetName();
         } else if (tag == UNUM_PUBLIC_RULESETS) {
             int32_t count = rbnf->getNumberOfRuleSetNames();
             for (int i = 0; i < count; ++i) {
                 res += rbnf->getRuleSetName(i);
                 res += (UChar)0x003b; // semicolon
             }
         } else {
@@ skipping 11 matching lines @@
             const    UChar*                            newValue,
             int32_t                            newValueLength,
             UErrorCode                        *status)
 {
     if(U_FAILURE(*status))
         return;
 
     int32_t len = (newValueLength == -1 ? u_strlen(newValue) : newValueLength);
     const UnicodeString val((UChar*)newValue, len, len);
     NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
-    DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
+    DecimalFormat* df = CR_DYNAMIC_CAST<DecimalFormat*>(nf);
     if (df != NULL) {
       switch(tag) {
       case UNUM_POSITIVE_PREFIX:
         df->setPositivePrefix(val);
         break;
         
       case UNUM_POSITIVE_SUFFIX:
         df->setPositiveSuffix(val);
         break;
         
@@ skipping 11 matching lines @@
         
       case UNUM_CURRENCY_CODE:
         df->setCurrency(newValue, *status);
         break;
         
       default:
         *status = U_UNSUPPORTED_ERROR;
         break;
       }
     } else {
-      RuleBasedNumberFormat* rbnf = dynamic_cast<RuleBasedNumberFormat*>(nf);
+      RuleBasedNumberFormat* rbnf = CR_DYNAMIC_CAST<RuleBasedNumberFormat*>(nf);
       U_ASSERT(rbnf != NULL);
       if (tag == UNUM_DEFAULT_RULESET) {
         rbnf->setDefaultRuleSet(newValue, *status);
       } else {
         *status = U_UNSUPPORTED_ERROR;
       }
     }
 }
 
 U_CAPI int32_t U_EXPORT2
 unum_toPattern(    const    UNumberFormat*          fmt,
         UBool                  isPatternLocalized,
         UChar*                  result,
         int32_t                 resultLength,
         UErrorCode*             status)
 {
     if(U_FAILURE(*status))
         return -1;
     
     UnicodeString pat;
     if(!(result==NULL && resultLength==0)) {
         // NULL destination for pure preflighting: empty dummy string
         // otherwise, alias the destination buffer
         pat.setTo(result, 0, resultLength);
     }
 
     const NumberFormat* nf = reinterpret_cast<const NumberFormat*>(fmt);
-    const DecimalFormat* df = dynamic_cast<const DecimalFormat*>(nf);
+    const DecimalFormat* df = CR_DYNAMIC_CAST<const DecimalFormat*>(nf);
     if (df != NULL) {
       if(isPatternLocalized)
         df->toLocalizedPattern(pat);
       else
         df->toPattern(pat);
     } else {
-      const RuleBasedNumberFormat* rbnf = dynamic_cast<const RuleBasedNumberFormat*>(nf);
+      const RuleBasedNumberFormat* rbnf = CR_DYNAMIC_CAST<const RuleBasedNumberFormat*>(nf);
       U_ASSERT(rbnf != NULL);
       pat = rbnf->getRules();
     }
     return pat.extract(result, resultLength, *status);
 }
 
 U_CAPI int32_t U_EXPORT2
 unum_getSymbol(const UNumberFormat *fmt,
                UNumberFormatSymbol symbol,
                UChar *buffer,
                int32_t size,
                UErrorCode *status)
 {
     if(status==NULL || U_FAILURE(*status)) {
         return 0;
     }
     if(fmt==NULL || (uint16_t)symbol>=UNUM_FORMAT_SYMBOL_COUNT) {
         *status=U_ILLEGAL_ARGUMENT_ERROR;
         return 0;
     }
     const NumberFormat *nf = reinterpret_cast<const NumberFormat *>(fmt);
-    const DecimalFormat *dcf = dynamic_cast<const DecimalFormat *>(nf);
+    const DecimalFormat *dcf = CR_DYNAMIC_CAST<const DecimalFormat *>(nf);
     if (dcf == NULL) {
       *status = U_UNSUPPORTED_ERROR;
       return 0;
     }
 
     return dcf->
       getDecimalFormatSymbols()->
         getConstSymbol((DecimalFormatSymbols::ENumberFormatSymbol)symbol).
           extract(buffer, size, *status);
 }
 
 U_CAPI void U_EXPORT2
 unum_setSymbol(UNumberFormat *fmt,
                UNumberFormatSymbol symbol,
                const UChar *value,
                int32_t length,
                UErrorCode *status)
 {
     if(status==NULL || U_FAILURE(*status)) {
         return;
     }
     if(fmt==NULL || (uint16_t)symbol>=UNUM_FORMAT_SYMBOL_COUNT || value==NULL || length<-1) {
         *status=U_ILLEGAL_ARGUMENT_ERROR;
         return;
     }
     NumberFormat *nf = reinterpret_cast<NumberFormat *>(fmt);
-    DecimalFormat *dcf = dynamic_cast<DecimalFormat *>(nf);
+    DecimalFormat *dcf = CR_DYNAMIC_CAST<DecimalFormat *>(nf);
     if (dcf == NULL) {
       *status = U_UNSUPPORTED_ERROR;
       return;
     }
 
     DecimalFormatSymbols symbols(*dcf->getDecimalFormatSymbols());
     symbols.setSymbol((DecimalFormatSymbols::ENumberFormatSymbol)symbol,
         UnicodeString(value, length));  /* UnicodeString can handle the case when length = -1. */
     dcf->setDecimalFormatSymbols(symbols);
 }
@@ skipping 15 matching lines @@
     
     if(status==NULL){
         status = &tStatus;
     }
     
     int32_t len = (patternLength == -1 ? u_strlen(pattern) : patternLength);
     const UnicodeString pat((UChar*)pattern, len, len);
 
     // Verify if the object passed is a DecimalFormat object
     NumberFormat* nf = reinterpret_cast<NumberFormat*>(fmt);
-    DecimalFormat* df = dynamic_cast<DecimalFormat*>(nf);
+    DecimalFormat* df = CR_DYNAMIC_CAST<DecimalFormat*>(nf);
     if (df != NULL) {
       if(localized) {
         df->applyLocalizedPattern(pat,*parseError, *status);
       } else {
         df->applyPattern(pat,*parseError, *status);
       }
     } else {
       *status = U_UNSUPPORTED_ERROR;
       return;
     }
 }
 
 U_CAPI const char* U_EXPORT2
 unum_getLocaleByType(const UNumberFormat *fmt,
                      ULocDataLocaleType type,
                      UErrorCode* status)
 {
     if (fmt == NULL) {
         if (U_SUCCESS(*status)) {
             *status = U_ILLEGAL_ARGUMENT_ERROR;
         }
         return NULL;
     }
     return ((const Format*)fmt)->getLocaleID(type, *status);
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */