Do not print error code if function returns I18N_ERROR_NONE and initialize local...

Change-Id: Id1602cd332f14f27cbadac12fc8c715a555f8b6d

diff --git a/src/include/mobile/utils_i18n_private.h b/src/include/mobile/utils_i18n_private.h
index d0eb6717d672e5972624b74b626b2d5a56451633..b981e4f89c264d9a970b1ed364665e0485c52fe0 100755 (executable)
--- a/src/include/mobile/utils_i18n_private.h
+++ b/src/include/mobile/utils_i18n_private.h
@@ -24,7 +24,6 @@
 
 /**
  * @file utils_i18n_private.h
- * @version 0.1
  * @brief utils_i18n_private
  */
 
@@ -37,7 +36,13 @@ extern "C" {
 #endif
 #define LOG_TAG "BASE_UTILS"
 
-#define ERR(fmt, arg...) SLOGE("%s:%d " fmt, __FUNCTION__, __LINE__, ##arg)
+#define I18N_ERR(ret) do { \
+    if (ret != I18N_ERROR_NONE) { \
+        LOGE("err(%d): %s", ret, get_error_message(ret)); \
+    } \
+} while (0)
+
+#define ERR(fmt, arg...) LOGE(fmt, ##arg)
 
 #define ret_if(expr) do { \
     if (expr) { \
@@ -45,18 +50,21 @@ extern "C" {
         return; \
     } \
 } while (0)
+
 #define retv_if(expr, val) do { \
     if (expr) { \
         ERR("(%s)", #expr); \
         return (val); \
     } \
 } while (0)
+
 #define retm_if(expr, fmt, arg...) do { \
     if (expr) { \
         ERR(fmt, ##arg); \
         return; \
     } \
 } while (0)
+
 #define retvm_if(expr, val, fmt, arg...) do { \
     if (expr) { \
         ERR(fmt, ##arg); \
@@ -70,7 +78,7 @@ extern "C" {
          val; \
          goto CATCH; \
       } \
-    } while (0);
+} while (0);
 
 #define ERR_MAPPING_REVERSE(BASE_UTILS_ERROR, ICU_ERROR) ICU_ERROR = \
     (UErrorCode)_i18n_error_mapping_reverse((int)BASE_UTILS_ERROR)

diff --git a/src/include/wearable/utils_i18n_private.h b/src/include/wearable/utils_i18n_private.h
index d0eb6717d672e5972624b74b626b2d5a56451633..b981e4f89c264d9a970b1ed364665e0485c52fe0 100755 (executable)
--- a/src/include/wearable/utils_i18n_private.h
+++ b/src/include/wearable/utils_i18n_private.h
@@ -24,7 +24,6 @@
 
 /**
  * @file utils_i18n_private.h
- * @version 0.1
  * @brief utils_i18n_private
  */
 
@@ -37,7 +36,13 @@ extern "C" {
 #endif
 #define LOG_TAG "BASE_UTILS"
 
-#define ERR(fmt, arg...) SLOGE("%s:%d " fmt, __FUNCTION__, __LINE__, ##arg)
+#define I18N_ERR(ret) do { \
+    if (ret != I18N_ERROR_NONE) { \
+        LOGE("err(%d): %s", ret, get_error_message(ret)); \
+    } \
+} while (0)
+
+#define ERR(fmt, arg...) LOGE(fmt, ##arg)
 
 #define ret_if(expr) do { \
     if (expr) { \
@@ -45,18 +50,21 @@ extern "C" {
         return; \
     } \
 } while (0)
+
 #define retv_if(expr, val) do { \
     if (expr) { \
         ERR("(%s)", #expr); \
         return (val); \
     } \
 } while (0)
+
 #define retm_if(expr, fmt, arg...) do { \
     if (expr) { \
         ERR(fmt, ##arg); \
         return; \
     } \
 } while (0)
+
 #define retvm_if(expr, val, fmt, arg...) do { \
     if (expr) { \
         ERR(fmt, ##arg); \
@@ -70,7 +78,7 @@ extern "C" {
          val; \
          goto CATCH; \
       } \
-    } while (0);
+} while (0);
 
 #define ERR_MAPPING_REVERSE(BASE_UTILS_ERROR, ICU_ERROR) ICU_ERROR = \
     (UErrorCode)_i18n_error_mapping_reverse((int)BASE_UTILS_ERROR)

diff --git a/src/utils_i18n_timezone.cpp b/src/utils_i18n_timezone.cpp
index 1bcd963c0c6780b45400f9d4c80db24902425bc9..e3dad207dc5c8f94a3083dd93fb2389f4a2db81d 100755 (executable)
--- a/src/utils_i18n_timezone.cpp
+++ b/src/utils_i18n_timezone.cpp
@@ -390,9 +390,12 @@ int i18n_timezone_in_daylight_time(i18n_timezone_h timezone, i18n_udate date, i1
 {
     retv_if(timezone == NULL || daylight_time == NULL, I18N_ERROR_INVALID_PARAMETER);
 
-    UErrorCode status;
+    UErrorCode status = U_ZERO_ERROR;
 
     *daylight_time = ((TimeZone*)timezone)->inDaylightTime(date, status);
+    i18n_error_code_e i18n_error;
+    ERR_MAPPING(status, i18n_error);
+    I18N_ERR(i18n_error);
 
     return _i18n_error_mapping(status);
 

diff --git a/src/utils_i18n_ubrk.c b/src/utils_i18n_ubrk.c
index 7f222d255052a40234cd9fe23c0e74a6524d45f0..79b86d77f3f175f01a30733651bd466910bb7c02 100644 (file)
--- a/src/utils_i18n_ubrk.c
+++ b/src/utils_i18n_ubrk.c
@@ -29,10 +29,10 @@ int i18n_ubrk_create (i18n_ubreak_iterator_type_e type, const char *locale, cons
     }
     UErrorCode icu_error = U_ZERO_ERROR;
     *break_iter = (i18n_ubreak_iterator_h) ubrk_open((UBreakIteratorType)type, locale, text, text_length, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
-
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -44,10 +44,11 @@ int i18n_ubrk_create_rules (const i18n_uchar *rules, int32_t rules_length, const
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *break_iter = (i18n_ubreak_iterator_h) ubrk_openRules (rules, rules_length, text, text_length, (UParseError*)parse_err, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -58,10 +59,11 @@ int i18n_ubrk_safe_clone (const i18n_ubreak_iterator_h break_iter, void *stack_b
     }
     UErrorCode icu_error = U_ZERO_ERROR;
     *break_iter_clone = (i18n_ubreak_iterator_h) ubrk_safeClone((const UBreakIterator*)break_iter, stack_buffer, p_buffer_size, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -83,10 +85,11 @@ int i18n_ubrk_set_text (i18n_ubreak_iterator_h break_iter, const i18n_uchar *tex
 
     UErrorCode icu_error = U_ZERO_ERROR;
     ubrk_setText((UBreakIterator*)break_iter, text, text_length, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -214,10 +217,11 @@ int32_t i18n_ubrk_get_rule_status_vec (i18n_ubreak_iterator_h break_iter, int32_
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_ubrk_getRuleStatusVec = ubrk_getRuleStatusVec((UBreakIterator*)break_iter, fill_in_vec, capacity, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ubrk_getRuleStatusVec;
 }
@@ -231,10 +235,11 @@ const char *i18n_ubrk_get_locale_by_type (const i18n_ubreak_iterator_h break_ite
     }
     UErrorCode icu_error = U_ZERO_ERROR;
     const char * result_ubrk_getLocaleByType = ubrk_getLocaleByType((const UBreakIterator*)break_iter, type, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ubrk_getLocaleByType;
 }

diff --git a/src/utils_i18n_ucalendar.c b/src/utils_i18n_ucalendar.c
index 92b8221881598cabaa8a46568c78247179dc4cd7..8cdb38f6f33e8d7c68b99af755ddc717b213f124 100644 (file)
--- a/src/utils_i18n_ucalendar.c
+++ b/src/utils_i18n_ucalendar.c
@@ -25,8 +25,9 @@ int i18n_ucalendar_create ( const i18n_uchar *zone_id, int32_t len, const char *
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *calendar = ucal_open(zone_id, len, locale, type, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -45,8 +46,9 @@ int i18n_ucalendar_clone ( const i18n_ucalendar_h cal, i18n_ucalendar_h *identic
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *identical_to_cal =  ucal_clone(cal, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -57,8 +59,9 @@ int i18n_ucalendar_add ( i18n_ucalendar_h calendar, i18n_ucalendar_date_fields_e
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     ucal_add(calendar, field, amount, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -77,8 +80,9 @@ int i18n_ucalendar_get_milliseconds ( const i18n_ucalendar_h calendar, i18n_udat
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *date = ucal_getMillis(calendar, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -89,8 +93,9 @@ int i18n_ucalendar_get ( const i18n_ucalendar_h calendar, i18n_ucalendar_date_fi
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *val = ucal_get(calendar, field, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -110,8 +115,9 @@ int i18n_ucalendar_get_timezone_displayname ( const i18n_ucalendar_h calendar, i
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *buf_size_needed = ucal_getTimeZoneDisplayName(calendar, type, locale, result, result_len, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+    
     return i18n_error;
 }
 
@@ -122,8 +128,9 @@ int i18n_ucalendar_is_in_daylight_time ( const i18n_ucalendar_h calendar, i18n_u
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *is_in = ucal_inDaylightTime(calendar, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -150,8 +157,9 @@ int i18n_ucalendar_set_date_time ( i18n_ucalendar_h calendar, int32_t year, int3
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     ucal_setDateTime(calendar, year, month, date, hour, min, sec, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -162,8 +170,9 @@ int i18n_ucalendar_set_milliseconds ( i18n_ucalendar_h calendar, i18n_udate mill
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     ucal_setMillis(calendar, milliseconds, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -174,8 +183,9 @@ int i18n_ucalendar_set_default_timezone ( const i18n_uchar *zone_id )
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     ucal_setDefaultTimeZone(zone_id, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -191,10 +201,10 @@ int32_t i18n_ucalendar_get_field_difference ( i18n_ucalendar_h calendar, i18n_ud
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result = ucal_getFieldDifference(calendar, target, field, &icu_error);
-    ERR("Error code: %d", icu_error);
 
     if(NULL != status) {
         ERR_MAPPING(icu_error, *status);
+        I18N_ERR(*status);
     }
 
     return result;
@@ -217,8 +227,9 @@ int i18n_ucalendar_timezone_id_enumeration_create ( i18n_system_timezone_type_e
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = (i18n_uenumeration_h)ucal_openTimeZoneIDEnumeration (zone_type, region, raw_offset, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -230,8 +241,9 @@ int i18n_ucalendar_timezones_create (i18n_uenumeration_h *enumeration)
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = (i18n_uenumeration_h)ucal_openTimeZones(&icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -243,8 +255,9 @@ int i18n_ucalendar_country_timezones_create (const char *country, i18n_uenumerat
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = (i18n_uenumeration_h)ucal_openCountryTimeZones(country, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -253,8 +266,8 @@ int32_t i18n_ucalendar_get_default_timezone (i18n_uchar *result, int32_t result_
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_ucal_getDefaultTimeZone = ucal_getDefaultTimeZone(result, result_capacity, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_ucal_getDefaultTimeZone;
 }
@@ -267,8 +280,9 @@ int i18n_ucalendar_set_timezone ( i18n_ucalendar_h calendar, const i18n_uchar *z
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     ucal_setTimeZone(calendar, zone_id, length, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -281,8 +295,9 @@ int32_t i18n_ucalendar_get_timezone_id (const  i18n_ucalendar_h calendar, i18n_u
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_ucal_getTimeZoneID = ucal_getTimeZoneID(calendar, result, result_length, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ucal_getTimeZoneID;
 }
@@ -295,8 +310,9 @@ int i18n_ucalendar_set_gregorian_change ( i18n_ucalendar_h calendar, i18n_udate
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     ucal_setGregorianChange(calendar, date, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 
 }
@@ -309,8 +325,9 @@ int i18n_ucalendar_get_gregorian_change ( const  i18n_ucalendar_h calendar, i18n
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *date = ucal_getGregorianChange(calendar, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -339,8 +356,9 @@ int i18n_ucalendar_set_date ( i18n_ucalendar_h calendar, int32_t year, int32_t m
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     ucal_setDate(calendar, year, month, date, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -352,8 +370,9 @@ int i18n_ucalendar_roll ( i18n_ucalendar_h calendar, i18n_ucalendar_date_fields_
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     ucal_roll(calendar, field, amount, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -395,8 +414,9 @@ int32_t i18n_ucalendar_get_limit ( const i18n_ucalendar_h calendar, i18n_ucalend
     i18n_error_code_e i18n_error = I18N_ERROR_NONE;
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_ucal_getLimit = ucal_getLimit(calendar, field, type, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
 
     return result_ucal_getLimit;
@@ -411,8 +431,9 @@ const char *i18n_ucalendar_get_locale_by_type ( const i18n_ucalendar_h calendar,
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     const char *result_ucal_getLocaleByType = ucal_getLocaleByType(calendar, type, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ucal_getLocaleByType;
 }
@@ -422,8 +443,9 @@ const char *i18n_ucalendar_get_tz_data_version (void)
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     const char *result_ucal_getTZDataVersion = ucal_getTZDataVersion(&icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ucal_getTZDataVersion;
 }
@@ -437,8 +459,9 @@ int32_t i18n_ucalendar_get_canonical_timezone_id ( const i18n_uchar *id, int32_t
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_ucal_getCanonicalTimeZoneID = ucal_getCanonicalTimeZoneID(id, length, result, result_capacity, is_system_id, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ucal_getCanonicalTimeZoneID ;
 }
@@ -452,8 +475,9 @@ const char *i18n_ucalendar_get_type ( const i18n_ucalendar_h calendar )
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     const char *result_ucal_getType = ucal_getType(calendar, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ucal_getType;
 }
@@ -466,8 +490,9 @@ int i18n_ucalendar_get_keyword_values_for_locale ( const char *key, const char *
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = (i18n_uenumeration_h )ucal_getKeywordValuesForLocale(key, locale, commonly_used, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -479,8 +504,9 @@ int i18n_ucalendar_get_day_of_week_type ( const i18n_ucalendar_h calendar, i18n_
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     *weekday_type = ucal_getDayOfWeekType(calendar, day_of_week, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -493,8 +519,9 @@ int32_t i18n_ucalendar_get_weekend_transition ( const i18n_ucalendar_h calendar,
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_ucal_getWeekendTransition = ucal_getWeekendTransition(calendar, day_of_week, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ucal_getWeekendTransition;
 }
@@ -508,8 +535,9 @@ i18n_ubool i18n_ucalendar_is_weekend ( i18n_ucalendar_h calendar, i18n_udate dat
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     i18n_ubool result_ucal_isWeekend = ucal_isWeekend(calendar, date, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ucal_isWeekend;
 }
@@ -523,8 +551,9 @@ i18n_ubool i18n_ucalendar_get_timezone_transition_date ( const i18n_ucalendar_h
     i18n_error_code_e i18n_error;
     UErrorCode icu_error = U_ZERO_ERROR;
     i18n_ubool result_ucal_getTimeZoneTransitionDate = ucal_getTimeZoneTransitionDate(calendar, type, transition, &icu_error);
-    ERR("ErrorCode : %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return result_ucal_getTimeZoneTransitionDate;
 }

diff --git a/src/utils_i18n_udate.c b/src/utils_i18n_udate.c
index c6de9c77841d84fb17abcf519ea5b415634c2a88..54c2bdbce38d86f332756947105d49235561046f 100644 (file)
--- a/src/utils_i18n_udate.c
+++ b/src/utils_i18n_udate.c
@@ -24,10 +24,11 @@ int i18n_udate_create ( i18n_udate_format_style_e time_style, i18n_udate_format_
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *format = udat_open(time_style, date_style, locale, tz_id, tz_id_len, pattern, pattern_len, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -45,10 +46,11 @@ int i18n_udate_format_date ( const i18n_udate_format_h format, i18n_udate date_t
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *buf_size_needed = udat_format(format, date_to_format, result, result_len, (UFieldPosition*)pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -65,7 +67,7 @@ int i18n_udate_to_calendar_date_field ( i18n_udate_format_field_e field, i18n_uc
         case I18N_UDATE_FORMAT_TIMEZONE_ISO_FIELD:
         case I18N_UDATE_FORMAT_TIMEZONE_ISO_LOCAL_FIELD:
         case I18N_UDATE_FORMAT_FIELD_COUNT:
-            ERR("Unsupported field");
+            LOGE("Unsupported field");
             return I18N_ERROR_INVALID_PARAMETER;
         default:
             *date_field_type = (i18n_ucalendar_date_fields_e)udat_toCalendarDateField(field);
@@ -83,10 +85,11 @@ int i18n_udate_clone ( const i18n_udate_format_h format, i18n_udate_format_h *fo
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *format_clone = (i18n_udate_format_h)udat_clone((const UDateFormat *)format, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -99,10 +102,11 @@ int i18n_udate_parse ( const i18n_udate_format_h format, const i18n_uchar *text,
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *parsed_date = udat_parse((const UDateFormat *)format, text, text_length, parse_pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -115,10 +119,11 @@ int i18n_udate_parse_calendar (const i18n_udate_format_h format, i18n_ucalendar_
 
     UErrorCode icu_error = U_ZERO_ERROR;
     udat_parseCalendar((const UDateFormat *)format, calendar, text, text_length, parse_pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -211,10 +216,11 @@ int i18n_udate_get_2digit_year_start ( const i18n_udate_format_h format, i18n_ud
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *year = (i18n_udate)udat_get2DigitYearStart((const UDateFormat *)format, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -227,10 +233,11 @@ int i18n_udate_set_2digit_year_start ( i18n_udate_format_h format, i18n_udate da
 
     UErrorCode icu_error = U_ZERO_ERROR;
     udat_set2DigitYearStart((UDateFormat *)format, date, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -244,10 +251,11 @@ int32_t i18n_udate_to_pattern ( const i18n_udate_format_h format, i18n_ubool loc
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = udat_toPattern((const UDateFormat *)format, localized, result, result_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -272,10 +280,11 @@ int32_t i18n_udate_get_symbols ( const i18n_udate_format_h format, i18n_udate_fo
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = udat_getSymbols((const UDateFormat *)format, type, symbol_index, result, result_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -301,10 +310,11 @@ int i18n_udate_set_symbols ( i18n_udate_format_h format, i18n_udate_format_symbo
 
     UErrorCode icu_error = U_ZERO_ERROR;
     udat_setSymbols((UDateFormat *)format, type, symbol_index, value, value_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -318,10 +328,11 @@ const char *i18n_udate_get_locale_by_type ( const i18n_udate_format_h format, i1
 
     UErrorCode icu_error = U_ZERO_ERROR;
     const char *locale_name = udat_getLocaleByType((const UDateFormat *)format, type, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     set_last_result(i18n_error);
     return locale_name;
 }
@@ -335,9 +346,10 @@ int i18n_udate_set_context ( i18n_udate_format_h format, i18n_udisplay_context_e
 
     UErrorCode icu_error = U_ZERO_ERROR;
     udat_setContext((UDateFormat *)format, value, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }

diff --git a/src/utils_i18n_udatepg.c b/src/utils_i18n_udatepg.c
index c314dd8729874e607539e22757c32813f97be90b..15952f9dc03e7d2be5429346dfbeb6a6ea22411d 100755 (executable)
--- a/src/utils_i18n_udatepg.c
+++ b/src/utils_i18n_udatepg.c
@@ -60,10 +60,11 @@ int i18n_udatepg_create_empty (i18n_udatepg_h *dtpg)
     }
     UErrorCode icu_error = U_ZERO_ERROR;
     *dtpg = (i18n_udatepg_h)udatpg_openEmpty(&icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -76,10 +77,10 @@ int i18n_udatepg_clone ( const i18n_udatepg_h dtpg, i18n_udatepg_h *dtpg_clone )
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *dtpg_clone = (i18n_udatepg_h)udatpg_clone((UDateTimePatternGenerator *)dtpg, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -94,10 +95,10 @@ int32_t i18n_udatepg_get_best_pattern_with_options ( i18n_udatepg_h dtpg, const
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t length_of_best_pattern = udatpg_getBestPatternWithOptions((UDateTimePatternGenerator *)dtpg, skeleton, length, options, best_pattern, capacity, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return length_of_best_pattern;
 }
@@ -113,10 +114,10 @@ int32_t i18n_udatepg_get_skeleton ( i18n_udatepg_h dtpg, const i18n_uchar *patte
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t length_of_skeleton = udatpg_getSkeleton((UDateTimePatternGenerator *)dtpg, pattern, length, skeleton, capacity, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return length_of_skeleton;
 }
@@ -132,10 +133,10 @@ int32_t i18n_udatepg_get_base_skeleton ( i18n_udatepg_h dtpg, const i18n_uchar *
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t length_of_skeleton = udatpg_getBaseSkeleton((UDateTimePatternGenerator *)dtpg, pattern, length, base_skeleton, capacity, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return length_of_skeleton;
 }
@@ -151,10 +152,10 @@ int32_t i18n_udatepg_add_pattern ( i18n_udatepg_h dtpg, const i18n_uchar *patter
     int32_t confliction_pattern_length;
     UErrorCode icu_error = U_ZERO_ERROR;
     *conflict_status = udatpg_addPattern((UDateTimePatternGenerator *)dtpg, pattern, pattern_length, override, conflicting_pattern, capacity, &confliction_pattern_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return confliction_pattern_length;
 }
@@ -270,10 +271,10 @@ int32_t i18n_udatepg_replace_field_types ( i18n_udatepg_h dtpg, const i18n_uchar
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t length_of_dest = udatpg_replaceFieldTypes((UDateTimePatternGenerator *)dtpg, pattern, pattern_length, skeleton, skeleton_length, dest, dest_capacity, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return length_of_dest;
 }
@@ -291,10 +292,10 @@ int32_t i18n_udatepg_replace_field_types_with_options ( i18n_udatepg_h dtpg, con
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t length_of_dest = udatpg_replaceFieldTypesWithOptions((UDateTimePatternGenerator *)dtpg, pattern, pattern_length, skeleton, skeleton_length, options, dest, dest_capacity, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return length_of_dest;
 }
@@ -308,10 +309,10 @@ int i18n_udatepg_skeletons_create ( const i18n_udatepg_h dtpg, i18n_uenumeration
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = udatpg_openSkeletons((const UDateTimePatternGenerator *)dtpg, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -324,10 +325,10 @@ int i18n_udatepg_base_skeletons_create ( const i18n_udatepg_h dtpg, i18n_uenumer
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = udatpg_openBaseSkeletons((const UDateTimePatternGenerator *)dtpg, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 

diff --git a/src/utils_i18n_uenumeration.c b/src/utils_i18n_uenumeration.c
index 20ebd11bd17a37d1497097cbf1dbfe1e6344b087..2c74487b4dbed13c2f9610219fda0d460097fe74 100755 (executable)
--- a/src/utils_i18n_uenumeration.c
+++ b/src/utils_i18n_uenumeration.c
@@ -39,10 +39,10 @@ int32_t i18n_uenumeration_count ( i18n_uenumeration_h enumeration )
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t number_of_elements = uenum_count((UEnumeration *)enumeration, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return number_of_elements;
 }
@@ -57,10 +57,10 @@ const i18n_uchar *i18n_uenumeration_unext ( i18n_uenumeration_h enumeration, int
 
     UErrorCode icu_error = U_ZERO_ERROR;
     const UChar *ustring = uenum_unext((UEnumeration *)enumeration, result_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return ustring;
 }
@@ -75,10 +75,10 @@ const char *i18n_uenumeration_next ( i18n_uenumeration_h enumeration, int32_t *r
 
     UErrorCode icu_error = U_ZERO_ERROR;
     const char *string = uenum_next((UEnumeration *)enumeration, result_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return string;
 }
@@ -92,10 +92,10 @@ int i18n_uenumeration_reset ( i18n_uenumeration_h enumeration )
 
     UErrorCode icu_error = U_ZERO_ERROR;
     uenum_reset((UEnumeration *)enumeration, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -108,10 +108,10 @@ int i18n_uenumeration_uchar_strings_enumeration_create ( const i18n_uchar *const
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = uenum_openUCharStringsEnumeration(strings, count, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -124,9 +124,9 @@ int i18n_uenumeration_char_strings_enumeration_create ( const char *const string
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = (i18n_uenumeration_h)uenum_openCharStringsEnumeration(strings, count, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }

diff --git a/src/utils_i18n_ulocale.c b/src/utils_i18n_ulocale.c
index c45fa30bde44509b89ac7e635d98575db6e51e73..e6339e8ffe9b71a3226490eb849f437c73849b7a 100755 (executable)
--- a/src/utils_i18n_ulocale.c
+++ b/src/utils_i18n_ulocale.c
@@ -100,10 +100,10 @@ int32_t i18n_ulocale_get_script (const char *locale_id, char *script, int32_t sc
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getScript(locale_id, script, script_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -117,10 +117,10 @@ int32_t i18n_ulocale_get_variant (const char *locale_id, char *variant, int32_t
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getVariant(locale_id, variant, variant_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -129,10 +129,10 @@ int32_t i18n_ulocale_get_name (const char *locale_id, char *name, int32_t name_c
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getName(locale_id, name, name_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -141,10 +141,10 @@ int32_t i18n_ulocale_canonicalize (const char *locale_id, char *name, int32_t na
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_canonicalize(locale_id, name, name_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -172,10 +172,10 @@ int32_t i18n_ulocale_get_display_language (const char *locale, const char *displ
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getDisplayLanguage(locale, display_locale, language, language_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -185,10 +185,10 @@ int32_t i18n_ulocale_get_display_script (const char *locale, const char *display
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getDisplayScript(locale, display_locale, script, script_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -198,10 +198,10 @@ int32_t i18n_ulocale_get_display_country (const char *locale, const char *displa
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getDisplayCountry(locale, display_locale, country, country_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -211,10 +211,10 @@ int32_t i18n_ulocale_get_display_variant (const char *locale, const char *displa
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getDisplayVariant(locale, display_locale, variant, variant_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -224,10 +224,10 @@ int32_t i18n_ulocale_get_display_keyword (const char *keyword, const char *displ
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getDisplayKeyword(keyword, display_locale, dest, dest_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -237,10 +237,10 @@ int32_t i18n_ulocale_get_display_keyword_value (const char *locale, const char *
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getDisplayKeywordValue(locale, keyword, display_locale, dest, dest_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -266,10 +266,10 @@ int32_t i18n_ulocale_get_parent (const char *locale_id, char *parent, int32_t pa
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t len_of_loc = uloc_getParent(locale_id, parent, parent_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return len_of_loc;
 }
@@ -278,10 +278,10 @@ int32_t i18n_ulocale_get_base_name (const char *locale_id, char *name, int32_t n
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getBaseName(locale_id, name, name_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -293,9 +293,9 @@ int i18n_ulocale_keywords_create (const char *locale_id, i18n_uenumeration_h *en
     }
     UErrorCode icu_error = U_ZERO_ERROR;
     *enumeration = (i18n_uenumeration_h)uloc_openKeywords(locale_id, &icu_error);
-    ERR("Error Code : %d", icu_error);
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -309,10 +309,10 @@ int32_t i18n_ulocale_get_keyword_value (const char *locale_id, const char *keywo
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t len_of_keyword = uloc_getKeywordValue(locale_id, keyword_name, buffer, buffer_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return len_of_keyword;
 }
@@ -327,10 +327,10 @@ int32_t i18n_ulocale_set_keyword_value (const char *keyword_name, const char *ke
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_setKeywordValue(keyword_name, keyword_value, buffer, buffer_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -342,10 +342,10 @@ int i18n_ulocale_get_character_orientation (const char *locale_id, i18n_ulocale_
     }
     UErrorCode icu_error = U_ZERO_ERROR;
     *layout_type = uloc_getCharacterOrientation(locale_id, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -356,10 +356,10 @@ int i18n_ulocale_get_line_orientation (const char *locale_id, i18n_ulocale_layou
     }
     UErrorCode icu_error = U_ZERO_ERROR;
    *layout_type = uloc_getLineOrientation(locale_id, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -372,10 +372,10 @@ int32_t i18n_ulocale_get_locale_for_lcid (uint32_t host_id, char *locale, int32_
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_getLocaleForLCID(host_id, locale, locale_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -385,10 +385,10 @@ int32_t i18n_ulocale_add_likely_subtags (const char *locale_id, char *maximized_
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_addLikelySubtags(locale_id, maximized_locale_id, maximized_locale_id_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -398,10 +398,10 @@ int32_t i18n_ulocale_minimize_subtags (const char *locale_id, char *minimized_lo
 {
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t needed_buffer_size = uloc_minimizeSubtags(locale_id, minimized_locale_id, minimized_locale_id_capacity, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return needed_buffer_size;
 }
@@ -416,10 +416,10 @@ int32_t i18n_ulocale_for_language_tag (const char *langtag, char *locale_id, int
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t len_of_loc = uloc_forLanguageTag(langtag, locale_id, locale_id_capacity, parsed_length, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return len_of_loc;
 }
@@ -434,10 +434,10 @@ int32_t i18n_ulocale_to_language_tag (const char *locale_id, char *langtag, int3
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t len_of_loc = uloc_toLanguageTag(locale_id, langtag, langtag_capacity, strict, &icu_error);
-    ERR("Error Code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return len_of_loc;
 }

diff --git a/src/utils_i18n_unumber.c b/src/utils_i18n_unumber.c
index d8498869105aad8dee0bf6a1b05cb1df044270d9..e568e44f3a8f4d1b09619f62615d9be121b712f7 100755 (executable)
--- a/src/utils_i18n_unumber.c
+++ b/src/utils_i18n_unumber.c
@@ -58,10 +58,10 @@ int i18n_unumber_clone(const i18n_unumber_format_h fmt, i18n_unumber_format_h *f
 
     UErrorCode icu_error = U_ZERO_ERROR;
     *fmt_clone = (i18n_unumber_format_h)unum_clone(fmt, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -76,9 +76,9 @@ int32_t i18n_unumber_format (const i18n_unumber_format_h fmt, int32_t number, i1
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_format = unum_format (fmt, number, (UChar*)result, result_length, (UFieldPosition*)pos, &icu_error);
-    ERR("Error code : %d", icu_error);
     if(NULL != status) {
         ERR_MAPPING(icu_error, *status);
+        I18N_ERR(*status);
     }
     return result_unum_format;
 }
@@ -92,11 +92,11 @@ int32_t i18n_unumber_format_int64 (const i18n_unumber_format_h fmt, int64_t numb
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_formatInt64 = unum_formatInt64 (fmt, number, result, result_length, (UFieldPosition*)pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
     set_last_result(i18n_error);
+    I18N_ERR(i18n_error);
     return result_unum_formatInt64;
 }
 
@@ -109,10 +109,10 @@ int32_t i18n_unumber_format_double (const i18n_unumber_format_h fmt, double numb
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_formatDouble = unum_formatDouble(fmt, number, result, result_length, (UFieldPosition*)pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_formatDouble;
 }
@@ -126,10 +126,10 @@ int32_t i18n_unumber_format_decimal (const i18n_unumber_format_h fmt, const char
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_formatDecimal = unum_formatDecimal (fmt, number, length, result, result_length, (UFieldPosition*)pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_formatDecimal;
 }
@@ -143,10 +143,10 @@ int32_t i18n_unumber_format_double_currency (const i18n_unumber_format_h fmt, do
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_formatDoubleCurrency = unum_formatDoubleCurrency (fmt, number, currency, result, result_length, (UFieldPosition*)pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_formatDoubleCurrency;
 }
@@ -160,10 +160,10 @@ int32_t i18n_unumber_parse (const i18n_unumber_format_h fmt, const i18n_uchar *t
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_parse = unum_parse (fmt, text, text_length, parse_pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_parse;
 }
@@ -177,10 +177,10 @@ int64_t i18n_unumber_parse_int64 (const i18n_unumber_format_h fmt, const i18n_uc
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int64_t result_unum_parseInt64 = unum_parseInt64 (fmt, text, text_length, parse_pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_parseInt64;
 }
@@ -194,10 +194,10 @@ double i18n_unumber_parse_double (const i18n_unumber_format_h fmt, const i18n_uc
 
     UErrorCode icu_error = U_ZERO_ERROR;
     double result_unum_parseDouble = unum_parseDouble (fmt, text, text_length, parse_pos, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_parseDouble;
 }
@@ -211,10 +211,10 @@ int32_t i18n_unumber_parse_decimal (const i18n_unumber_format_h fmt, const i18n_
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_parseDecimal = unum_parseDecimal (fmt, text, text_length, parse_pos, out_buf, out_buf_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_parseDecimal;
 }
@@ -228,10 +228,10 @@ double i18n_unumber_parse_double_currency (const i18n_unumber_format_h fmt, cons
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_parseDoubleCurrency = unum_parseDoubleCurrency (fmt, text, text_length, parse_pos, currency, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_parseDoubleCurrency;
 }
@@ -244,10 +244,11 @@ int i18n_unumber_apply_pattern (i18n_unumber_format_h format, i18n_ubool localiz
 
     UErrorCode icu_error = U_ZERO_ERROR;
     unum_applyPattern (format, localized, pattern, pattern_length, (UParseError*)parse_error, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -319,10 +320,10 @@ int32_t i18n_unumber_get_text_attribute (const i18n_unumber_format_h fmt, i18n_u
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_getTextAttribute = unum_getTextAttribute (fmt, tag, result, result_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_getTextAttribute;
 }
@@ -335,10 +336,10 @@ int i18n_unumber_set_text_attribute (const i18n_unumber_format_h fmt, i18n_unumb
 
     UErrorCode icu_error = U_ZERO_ERROR;
     unum_setTextAttribute((UNumberFormat*)fmt, tag, new_value, new_value_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -351,10 +352,10 @@ int32_t i18n_unumber_to_pattern (const i18n_unumber_format_h fmt, i18n_ubool is_
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_unum_toPattern = unum_toPattern(fmt, is_pattern_localized, result, result_length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_toPattern;
 }
@@ -367,10 +368,10 @@ int i18n_unumber_set_symbol (i18n_unumber_format_h fmt, i18n_unumber_format_symb
 
     UErrorCode icu_error = U_ZERO_ERROR;
     unum_setSymbol(fmt, symbol, value, length, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -383,10 +384,10 @@ const char *i18n_unumber_get_locale_by_type (const i18n_unumber_format_h fmt, i1
 
     UErrorCode icu_error = U_ZERO_ERROR;
     const char *result_unum_getLocaleByType = unum_getLocaleByType (fmt, type, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     set_last_result(i18n_error);
     return result_unum_getLocaleByType;
 }

diff --git a/src/utils_i18n_usearch.c b/src/utils_i18n_usearch.c
index d45da0f4d68ba79f605e79a3fd39bd1f3ef784a7..74aa15170024b5e896971371997ce0f1146f50ff 100755 (executable)
--- a/src/utils_i18n_usearch.c
+++ b/src/utils_i18n_usearch.c
@@ -33,7 +33,7 @@ int i18n_usearch_first ( i18n_usearch_h strsrch, int32_t *index_first )
     UErrorCode err = U_ZERO_ERROR;
     *index_first = usearch_first ( strsrch, &err );
     int result = _i18n_error_mapping ( err );
-    ERR("ErrorCode : %d", result);
+    I18N_ERR(result);
 
     return result;
 }
@@ -51,7 +51,7 @@ int i18n_usearch_get_matched_text ( const i18n_usearch_h strsrch, i18n_uchar *re
     UErrorCode err = U_ZERO_ERROR;
     *len_matched_text = usearch_getMatchedText ( strsrch, result_w, result_capacity, &err );
     int result = _i18n_error_mapping ( err );
-    ERR("ErrorCode : %d", result);
+    I18N_ERR(result);
 
     return result;
 }
@@ -73,10 +73,10 @@ int i18n_usearch_create_new ( const i18n_uchar *pattern, int32_t pattern_len, co
     retv_if ( search_iter == NULL, I18N_ERROR_INVALID_PARAMETER );
     UErrorCode icu_error = U_ZERO_ERROR;
     *search_iter = (i18n_usearch_h)usearch_open(pattern, pattern_len, text, text_len, locale, (UBreakIterator*)break_iter, &icu_error);
-    ERR("Error code : %d", icu_error);
 
     i18n_error_code_e i18n_error;
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
 
     return i18n_error;
 }

diff --git a/src/utils_i18n_uset.c b/src/utils_i18n_uset.c
index 77b16cf221d8411c1ba951c94a30de0e3895eac8..75ebe4b6f8897a7e4d1809add9857ac499a6ea47 100644 (file)
--- a/src/utils_i18n_uset.c
+++ b/src/utils_i18n_uset.c
@@ -49,8 +49,9 @@ int i18n_uset_create_pattern ( const i18n_uchar *pattern, int32_t pattern_length
     }
 
     *set = (i18n_uset_h)uset_openPattern(pattern, pattern_length, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
+
     return i18n_error;
 }
 
@@ -67,8 +68,8 @@ int i18n_uset_create_pattern_options ( const i18n_uchar *pattern, int32_t patter
     }
 
     *set = (i18n_uset_h)uset_openPatternOptions(pattern, pattern_length, options, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
     return i18n_error;
 }
 
@@ -150,8 +151,8 @@ int32_t i18n_uset_apply_pattern ( i18n_uset_h set, const i18n_uchar *pattern, in
     i18n_error_code_e i18n_error;
 
     int32_t result_uset_applyPattern = uset_applyPattern ((USet*)set, pattern, pattern_length, options, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
 
     set_last_result(i18n_error);
     return result_uset_applyPattern;
@@ -176,8 +177,8 @@ int i18n_uset_apply_int_property_value ( i18n_uset_h set, i18n_uchar_uproperty_e
     i18n_error_code_e i18n_error;
 
     uset_applyIntPropertyValue((USet *)set, prop, value, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
 
     return i18n_error;
 }
@@ -198,8 +199,8 @@ int i18n_uset_apply_property_alias ( i18n_uset_h set, const i18n_uchar *prop, in
     i18n_error_code_e i18n_error;
 
     uset_applyPropertyAlias ((USet*)set, prop, prop_length, value, value_length, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
 
     return i18n_error;
 
@@ -226,8 +227,8 @@ int32_t i18n_uset_to_pattern ( const i18n_uset_h set, i18n_uchar *result, int32_
     i18n_error_code_e i18n_error;
 
     int32_t result_uset_toPattern = uset_toPattern((const USet*)set, result, result_capacity, escape_unprintable, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
 
     set_last_result(i18n_error);
     return result_uset_toPattern;
@@ -495,8 +496,8 @@ int32_t i18n_uset_get_item ( const i18n_uset_h set, int32_t item_index, i18n_uch
     i18n_error_code_e i18n_error;
 
     int32_t result_uset_getItem = uset_getItem((const USet*)set, item_index, start, end, str, str_capacity, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
 
     set_last_result(i18n_error);
     return result_uset_getItem;
@@ -642,8 +643,8 @@ int32_t i18n_uset_serialize ( const i18n_uset_h set, uint16_t *dest, int32_t des
 
     UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result_uset_serialize =  uset_serialize((const USet*)set, dest, dest_capacity, &icu_error);
-    ERR("Error code: %d", icu_error);
     ERR_MAPPING(icu_error, i18n_error);
+    I18N_ERR(i18n_error);
 
     set_last_result(i18n_error);
     return result_uset_serialize;

diff --git a/src/utils_i18n_ustring.c b/src/utils_i18n_ustring.c
index 319a4b0891eda145c7ac6ef823a2c4438602b9d4..730b4a6c2c43f9daa0e5bb05a583b7d5b3c20cfd 100644 (file)
--- a/src/utils_i18n_ustring.c
+++ b/src/utils_i18n_ustring.c
@@ -542,6 +542,7 @@ int32_t i18n_ustring_fold_case ( i18n_uchar *dest, int32_t dest_capacity, const
    UErrorCode icu_error = U_ZERO_ERROR;
     int32_t result =u_strFoldCase (dest, dest_capacity, src, src_len, options, &icu_error);
     *i18n_error = _i18n_error_mapping(icu_error);
+    I18N_ERR(*i18n_error);
 
     return result;
 }