ICU 56 update step 1

source/i18n/udat.cpp

 /*
 *******************************************************************************
-*   Copyright (C) 1996-2014, International Business Machines
+*   Copyright (C) 1996-2015, International Business Machines
 *   Corporation and others.  All Rights Reserved.
 *******************************************************************************
 */
 
 #include "unicode/utypes.h"
 
 #if !UCONFIG_NO_FORMATTING
 
 #include "unicode/udat.h"
 
 #include "unicode/uloc.h"
 #include "unicode/datefmt.h"
 #include "unicode/timezone.h"
 #include "unicode/smpdtfmt.h"
 #include "unicode/fieldpos.h"
 #include "unicode/parsepos.h"
 #include "unicode/calendar.h"
 #include "unicode/numfmt.h"
 #include "unicode/dtfmtsym.h"
 #include "unicode/ustring.h"
 #include "unicode/udisplaycontext.h"
+#include "unicode/ufieldpositer.h"
 #include "cpputils.h"
 #include "reldtfmt.h"
 #include "umutex.h"
 
 U_NAMESPACE_USE
 
 /**
  * Verify that fmt is a SimpleDateFormat. Invalid error if not.
  * @param fmt the UDateFormat, definitely a DateFormat, maybe something else
  * @param status error code, will be set to failure if there is a familure or the fmt is NULL.
@@ skipping 171 matching lines @@
 }
 
 U_CAPI int32_t U_EXPORT2
 udat_format(    const    UDateFormat*    format,
         UDate           dateToFormat,
         UChar*          result,
         int32_t         resultLength,
         UFieldPosition* position,
         UErrorCode*     status)
 {
-    if(U_FAILURE(*status)) return -1;
+    if(U_FAILURE(*status)) {
+        return -1;
+    }
+    if (result == NULL ? resultLength != 0 : resultLength < 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return -1;
+    }
 
     UnicodeString res;
-    if(!(result==NULL && resultLength==0)) {
+    if (result != NULL) {
         // NULL destination for pure preflighting: empty dummy string
         // otherwise, alias the destination buffer
         res.setTo(result, 0, resultLength);
     }
 
     FieldPosition fp;
 
     if(position != 0)
         fp.setField(position->field);
 
     ((DateFormat*)format)->format(dateToFormat, res, fp);
 
     if(position != 0) {
         position->beginIndex = fp.getBeginIndex();
         position->endIndex = fp.getEndIndex();
     }
 
     return res.extract(result, resultLength, *status);
 }
 
+U_CAPI int32_t U_EXPORT2
+udat_formatCalendar(const UDateFormat*  format,
+        UCalendar*      calendar,
+        UChar*          result,
+        int32_t         resultLength,
+        UFieldPosition* position,
+        UErrorCode*     status)
+{
+    if(U_FAILURE(*status)) {
+        return -1;
+    }
+    if (result == NULL ? resultLength != 0 : resultLength < 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return -1;
+    }
+
+    UnicodeString res;
+    if (result != NULL) {
+        // NULL destination for pure preflighting: empty dummy string
+        // otherwise, alias the destination buffer
+        res.setTo(result, 0, resultLength);
+    }
+
+    FieldPosition fp;
+
+    if(position != 0)
+        fp.setField(position->field);
+
+    ((DateFormat*)format)->format(*(Calendar*)calendar, res, fp);
+
+    if(position != 0) {
+        position->beginIndex = fp.getBeginIndex();
+        position->endIndex = fp.getEndIndex();
+    }
+
+    return res.extract(result, resultLength, *status);
+}
+
+U_CAPI int32_t U_EXPORT2
+udat_formatForFields(    const    UDateFormat*    format,
+        UDate           dateToFormat,
+        UChar*          result,
+        int32_t         resultLength,
+        UFieldPositionIterator* fpositer,
+        UErrorCode*     status)
+{
+    if(U_FAILURE(*status)) {
+        return -1;
+    }
+    if (result == NULL ? resultLength != 0 : resultLength < 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return -1;
+    }
+
+    UnicodeString res;
+    if (result != NULL) {
+        // NULL destination for pure preflighting: empty dummy string
+        // otherwise, alias the destination buffer
+        res.setTo(result, 0, resultLength);
+    }
+
+    ((DateFormat*)format)->format(dateToFormat, res, (FieldPositionIterator*)fpositer, *status);
+
+    return res.extract(result, resultLength, *status);
+}
+
+U_CAPI int32_t U_EXPORT2
+udat_formatCalendarForFields(const UDateFormat*  format,
+        UCalendar*      calendar,
+        UChar*          result,
+        int32_t         resultLength,
+        UFieldPositionIterator* fpositer,
+        UErrorCode*     status)
+{
+    if(U_FAILURE(*status)) {
+        return -1;
+    }
+    if (result == NULL ? resultLength != 0 : resultLength < 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return -1;
+    }
+
+    UnicodeString res;
+    if (result != NULL) {
+        // NULL destination for pure preflighting: empty dummy string
+        // otherwise, alias the destination buffer
+        res.setTo(result, 0, resultLength);
+    }
+
+    ((DateFormat*)format)->format(*(Calendar*)calendar, res, (FieldPositionIterator*)fpositer, *status);
+
+    return res.extract(result, resultLength, *status);
+}
+
 U_CAPI UDate U_EXPORT2
 udat_parse(    const    UDateFormat*        format,
         const    UChar*          text,
         int32_t         textLength,
         int32_t         *parsePos,
         UErrorCode      *status)
 {
     if(U_FAILURE(*status)) return (UDate)0;
 
     const UnicodeString src((UBool)(textLength == -1), text, textLength);
@@ skipping 24 matching lines @@
                             UCalendar*      calendar,
                    const    UChar*          text,
                             int32_t         textLength,
                             int32_t         *parsePos,
                             UErrorCode      *status)
 {
     if(U_FAILURE(*status)) return;
 
     const UnicodeString src((UBool)(textLength == -1), text, textLength);
     ParsePosition pp;
+    int32_t stackParsePos = 0;
 
-    if(parsePos != 0)
-        pp.setIndex(*parsePos);
+    if(parsePos == NULL) {
+        parsePos = &stackParsePos;
+    }
+
+    pp.setIndex(*parsePos);
 
     ((DateFormat*)format)->parse(src, *(Calendar*)calendar, pp);
 
-    if(parsePos != 0) {
-        if(pp.getErrorIndex() == -1)
-            *parsePos = pp.getIndex();
-        else {
-            *parsePos = pp.getErrorIndex();
-            *status = U_PARSE_ERROR;
-        }
+    if(pp.getErrorIndex() == -1)
+        *parsePos = pp.getIndex();
+    else {
+        *parsePos = pp.getErrorIndex();
+        *status = U_PARSE_ERROR;
     }
 }
 
 U_CAPI UBool U_EXPORT2
 udat_isLenient(const UDateFormat* fmt)
 {
     return ((DateFormat*)fmt)->isLenient();
 }
 
 U_CAPI void U_EXPORT2
@@ skipping 111 matching lines @@
     ((SimpleDateFormat*)fmt)->set2DigitYearStart(d, *status);
 }
 
 U_CAPI int32_t U_EXPORT2
 udat_toPattern(    const   UDateFormat     *fmt,
         UBool          localized,
         UChar           *result,
         int32_t         resultLength,
         UErrorCode      *status)
 {
-    if(U_FAILURE(*status)) return -1;
+    if(U_FAILURE(*status)) {
+        return -1;
+    }
+    if (result == NULL ? resultLength != 0 : resultLength < 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return -1;
+    }
 
     UnicodeString res;
-    if(!(result==NULL && resultLength==0)) {
+    if (result != NULL) {
         // NULL destination for pure preflighting: empty dummy string
         // otherwise, alias the destination buffer
         res.setTo(result, 0, resultLength);
     }
 
     const DateFormat *df=reinterpret_cast<const DateFormat *>(fmt);
     const SimpleDateFormat *sdtfmt=dynamic_cast<const SimpleDateFormat *>(df);
     const RelativeDateFormat *reldtfmt;
     if (sdtfmt!=NULL) {
         if(localized)
@@ skipping 695 matching lines @@
 }
 
 
 U_CAPI int32_t U_EXPORT2 
 udat_toPatternRelativeDate(const UDateFormat *fmt,
                            UChar             *result,
                            int32_t           resultLength,
                            UErrorCode        *status)
 {
     verifyIsRelativeDateFormat(fmt, status);
-    if(U_FAILURE(*status)) return -1;
+    if(U_FAILURE(*status)) {
+        return -1;
+    }
+    if (result == NULL ? resultLength != 0 : resultLength < 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return -1;
+    }
 
     UnicodeString datePattern;
-    if(!(result==NULL && resultLength==0)) {
+    if (result != NULL) {
         // NULL destination for pure preflighting: empty dummy string
         // otherwise, alias the destination buffer
         datePattern.setTo(result, 0, resultLength);
     }
     ((RelativeDateFormat*)fmt)->toPatternDate(datePattern, *status);
     return datePattern.extract(result, resultLength, *status);
 }
 
 U_CAPI int32_t U_EXPORT2 
 udat_toPatternRelativeTime(const UDateFormat *fmt,
                            UChar             *result,
                            int32_t           resultLength,
                            UErrorCode        *status)
 {
     verifyIsRelativeDateFormat(fmt, status);
-    if(U_FAILURE(*status)) return -1;
+    if(U_FAILURE(*status)) {
+        return -1;
+    }
+    if (result == NULL ? resultLength != 0 : resultLength < 0) {
+        *status = U_ILLEGAL_ARGUMENT_ERROR;
+        return -1;
+    }
 
     UnicodeString timePattern;
-    if(!(result==NULL && resultLength==0)) {
+    if (result != NULL) {
         // NULL destination for pure preflighting: empty dummy string
         // otherwise, alias the destination buffer
         timePattern.setTo(result, 0, resultLength);
     }
     ((RelativeDateFormat*)fmt)->toPatternTime(timePattern, *status);
     return timePattern.extract(result, resultLength, *status);
 }
 
 U_CAPI void U_EXPORT2 
 udat_applyPatternRelative(UDateFormat *format,
                           const UChar *datePattern,
                           int32_t     datePatternLength,
                           const UChar *timePattern,
                           int32_t     timePatternLength,
                           UErrorCode  *status)
 {
     verifyIsRelativeDateFormat(format, status);
     if(U_FAILURE(*status)) return;
     const UnicodeString datePat((UBool)(datePatternLength == -1), datePattern, datePatternLength);
     const UnicodeString timePat((UBool)(timePatternLength == -1), timePattern, timePatternLength);
     ((RelativeDateFormat*)format)->applyPatterns(datePat, timePat, *status);
 }
 
 #endif /* #if !UCONFIG_NO_FORMATTING */