| /* | |
| ******************************************************************************* | |
| * | |
| * Copyright (C) 1999-2012, International Business Machines | |
| * Corporation and others. All Rights Reserved. | |
| * | |
| ******************************************************************************* | |
| * file name: umsg.cpp | |
| * encoding: US-ASCII | |
| * tab size: 8 (not used) | |
| * indentation:4 | |
| * | |
| * This is a C wrapper to MessageFormat C++ API. | |
| * | |
| * Change history: | |
| * | |
| * 08/5/2001 Ram Added C wrappers for C++ API. Changed implementation of old API's | |
| * Removed pattern parser. | |
| * | |
| */ | |
| #include "starboard/client_porting/poem/assert_poem.h" | |
| #include "unicode/utypes.h" | |
| #if !UCONFIG_NO_FORMATTING | |
| #include "unicode/umsg.h" | |
| #include "unicode/ustring.h" | |
| #include "unicode/fmtable.h" | |
| #include "unicode/msgfmt.h" | |
| #include "unicode/unistr.h" | |
| #include "cpputils.h" | |
| #include "uassert.h" | |
| #include "ustr_imp.h" | |
| U_NAMESPACE_BEGIN | |
| /** | |
| * This class isolates our access to private internal methods of | |
| * MessageFormat. It is never instantiated; it exists only for C++ | |
| * access management. | |
| */ | |
| class MessageFormatAdapter { | |
| public: | |
| static const Formattable::Type* getArgTypeList(const MessageFormat& m, | |
| int32_t& count); | |
| static UBool hasArgTypeConflicts(const MessageFormat& m) { | |
| return m.hasArgTypeConflicts; | |
| } | |
| }; | |
| const Formattable::Type* | |
| MessageFormatAdapter::getArgTypeList(const MessageFormat& m, | |
| int32_t& count) { | |
| return m.getArgTypeList(count); | |
| } | |
| U_NAMESPACE_END | |
| U_NAMESPACE_USE | |
| U_CAPI int32_t | |
| u_formatMessage(const char *locale, | |
| const UChar *pattern, | |
| int32_t patternLength, | |
| UChar *result, | |
| int32_t resultLength, | |
| UErrorCode *status, | |
| ...) | |
| { | |
| va_list ap; | |
| int32_t actLen; | |
| //argument checking defered to subsequent method calls | |
| // start vararg processing | |
| va_start(ap, status); | |
| actLen = u_vformatMessage(locale,pattern,patternLength,result,resultLength,ap,status); | |
| // end vararg processing | |
| va_end(ap); | |
| return actLen; | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| u_vformatMessage( const char *locale, | |
| const UChar *pattern, | |
| int32_t patternLength, | |
| UChar *result, | |
| int32_t resultLength, | |
| va_list ap, | |
| UErrorCode *status) | |
| { | |
| //argument checking defered to subsequent method calls | |
| UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,NULL,status); | |
| int32_t retVal = umsg_vformat(fmt,result,resultLength,ap,status); | |
| umsg_close(fmt); | |
| return retVal; | |
| } | |
| U_CAPI int32_t | |
| u_formatMessageWithError(const char *locale, | |
| const UChar *pattern, | |
| int32_t patternLength, | |
| UChar *result, | |
| int32_t resultLength, | |
| UParseError *parseError, | |
| UErrorCode *status, | |
| ...) | |
| { | |
| va_list ap; | |
| int32_t actLen; | |
| //argument checking defered to subsequent method calls | |
| // start vararg processing | |
| va_start(ap, status); | |
| actLen = u_vformatMessageWithError(locale,pattern,patternLength,result,resultLength,parseError,ap,status); | |
| // end vararg processing | |
| va_end(ap); | |
| return actLen; | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| u_vformatMessageWithError( const char *locale, | |
| const UChar *pattern, | |
| int32_t patternLength, | |
| UChar *result, | |
| int32_t resultLength, | |
| UParseError *parseError, | |
| va_list ap, | |
| UErrorCode *status) | |
| { | |
| //argument checking defered to subsequent method calls | |
| UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,parseError,status); | |
| int32_t retVal = umsg_vformat(fmt,result,resultLength,ap,status); | |
| umsg_close(fmt); | |
| return retVal; | |
| } | |
| // For parse, do the reverse of format: | |
| // 1. Call through to the C++ APIs | |
| // 2. Just assume the user passed in enough arguments. | |
| // 3. Iterate through each formattable returned, and assign to the arguments | |
| U_CAPI void | |
| u_parseMessage( const char *locale, | |
| const UChar *pattern, | |
| int32_t patternLength, | |
| const UChar *source, | |
| int32_t sourceLength, | |
| UErrorCode *status, | |
| ...) | |
| { | |
| va_list ap; | |
| //argument checking defered to subsequent method calls | |
| // start vararg processing | |
| va_start(ap, status); | |
| u_vparseMessage(locale,pattern,patternLength,source,sourceLength,ap,status); | |
| // end vararg processing | |
| va_end(ap); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| u_vparseMessage(const char *locale, | |
| const UChar *pattern, | |
| int32_t patternLength, | |
| const UChar *source, | |
| int32_t sourceLength, | |
| va_list ap, | |
| UErrorCode *status) | |
| { | |
| //argument checking defered to subsequent method calls | |
| UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,NULL,status); | |
| int32_t count = 0; | |
| umsg_vparse(fmt,source,sourceLength,&count,ap,status); | |
| umsg_close(fmt); | |
| } | |
| U_CAPI void | |
| u_parseMessageWithError(const char *locale, | |
| const UChar *pattern, | |
| int32_t patternLength, | |
| const UChar *source, | |
| int32_t sourceLength, | |
| UParseError *error, | |
| UErrorCode *status, | |
| ...) | |
| { | |
| va_list ap; | |
| //argument checking defered to subsequent method calls | |
| // start vararg processing | |
| va_start(ap, status); | |
| u_vparseMessageWithError(locale,pattern,patternLength,source,sourceLength,ap,error,status); | |
| // end vararg processing | |
| va_end(ap); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| u_vparseMessageWithError(const char *locale, | |
| const UChar *pattern, | |
| int32_t patternLength, | |
| const UChar *source, | |
| int32_t sourceLength, | |
| va_list ap, | |
| UParseError *error, | |
| UErrorCode* status) | |
| { | |
| //argument checking defered to subsequent method calls | |
| UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,error,status); | |
| int32_t count = 0; | |
| umsg_vparse(fmt,source,sourceLength,&count,ap,status); | |
| umsg_close(fmt); | |
| } | |
| ////////////////////////////////////////////////////////////////////////////////// | |
| // | |
| // Message format C API | |
| // | |
| ///////////////////////////////////////////////////////////////////////////////// | |
| U_CAPI UMessageFormat* U_EXPORT2 | |
| umsg_open( const UChar *pattern, | |
| int32_t patternLength, | |
| const char *locale, | |
| UParseError *parseError, | |
| UErrorCode *status) | |
| { | |
| //check arguments | |
| if(status==NULL || U_FAILURE(*status)) | |
| { | |
| return 0; | |
| } | |
| if(pattern==NULL||patternLength<-1){ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| return 0; | |
| } | |
| UParseError tErr; | |
| if(parseError==NULL) | |
| { | |
| parseError = &tErr; | |
| } | |
| int32_t len = (patternLength == -1 ? u_strlen(pattern) : patternLength); | |
| UnicodeString patString(patternLength == -1, pattern, len); | |
| MessageFormat* retVal = new MessageFormat(patString,Locale(locale),*parseError,*status); | |
| if(retVal == NULL) { | |
| *status = U_MEMORY_ALLOCATION_ERROR; | |
| return NULL; | |
| } | |
| if (U_SUCCESS(*status) && MessageFormatAdapter::hasArgTypeConflicts(*retVal)) { | |
| *status = U_ARGUMENT_TYPE_MISMATCH; | |
| } | |
| return (UMessageFormat*)retVal; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| umsg_close(UMessageFormat* format) | |
| { | |
| //check arguments | |
| if(format==NULL){ | |
| return; | |
| } | |
| delete (MessageFormat*) format; | |
| } | |
| U_CAPI UMessageFormat U_EXPORT2 | |
| umsg_clone(const UMessageFormat *fmt, | |
| UErrorCode *status) | |
| { | |
| //check arguments | |
| if(status==NULL || U_FAILURE(*status)){ | |
| return NULL; | |
| } | |
| if(fmt==NULL){ | |
| *status = U_ILLEGAL_ARGUMENT_ERROR; | |
| return NULL; | |
| } | |
| UMessageFormat retVal = (UMessageFormat)((MessageFormat*)fmt)->clone(); | |
| if(retVal == 0) { | |
| *status = U_MEMORY_ALLOCATION_ERROR; | |
| return 0; | |
| } | |
| return retVal; | |
| } | |
| U_CAPI void U_EXPORT2 | |
| umsg_setLocale(UMessageFormat *fmt, const char* locale) | |
| { | |
| //check arguments | |
| if(fmt==NULL){ | |
| return; | |
| } | |
| ((MessageFormat*)fmt)->setLocale(Locale(locale)); | |
| } | |
| U_CAPI const char* U_EXPORT2 | |
| umsg_getLocale(const UMessageFormat *fmt) | |
| { | |
| //check arguments | |
| if(fmt==NULL){ | |
| return ""; | |
| } | |
| return ((const MessageFormat*)fmt)->getLocale().getName(); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| umsg_applyPattern(UMessageFormat *fmt, | |
| const UChar* pattern, | |
| int32_t patternLength, | |
| UParseError* parseError, | |
| UErrorCode* status) | |
| { | |
| //check arguments | |
| UParseError tErr; | |
| if(status ==NULL||U_FAILURE(*status)){ | |
| return ; | |
| } | |
| if(fmt==NULL||pattern==NULL||patternLength<-1){ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| return ; | |
| } | |
| if(parseError==NULL){ | |
| parseError = &tErr; | |
| } | |
| if(patternLength<-1){ | |
| patternLength=u_strlen(pattern); | |
| } | |
| ((MessageFormat*)fmt)->applyPattern(UnicodeString(pattern,patternLength),*parseError,*status); | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| umsg_toPattern(const UMessageFormat *fmt, | |
| UChar* result, | |
| int32_t resultLength, | |
| UErrorCode* status) | |
| { | |
| //check arguments | |
| if(status ==NULL||U_FAILURE(*status)){ | |
| return -1; | |
| } | |
| if(fmt==NULL||resultLength<0 || (resultLength>0 && result==0)){ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| 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 MessageFormat*)fmt)->toPattern(res); | |
| return res.extract(result, resultLength, *status); | |
| } | |
| U_CAPI int32_t | |
| umsg_format( const UMessageFormat *fmt, | |
| UChar *result, | |
| int32_t resultLength, | |
| UErrorCode *status, | |
| ...) | |
| { | |
| va_list ap; | |
| int32_t actLen; | |
| //argument checking defered to last method call umsg_vformat which | |
| //saves time when arguments are valid and we dont care when arguments are not | |
| //since we return an error anyway | |
| // start vararg processing | |
| va_start(ap, status); | |
| actLen = umsg_vformat(fmt,result,resultLength,ap,status); | |
| // end vararg processing | |
| va_end(ap); | |
| return actLen; | |
| } | |
| U_CAPI int32_t U_EXPORT2 | |
| umsg_vformat( const UMessageFormat *fmt, | |
| UChar *result, | |
| int32_t resultLength, | |
| va_list ap, | |
| UErrorCode *status) | |
| { | |
| //check arguments | |
| if(status==0 || U_FAILURE(*status)) | |
| { | |
| return -1; | |
| } | |
| if(fmt==NULL||resultLength<0 || (resultLength>0 && result==0)) { | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| return -1; | |
| } | |
| int32_t count =0; | |
| const Formattable::Type* argTypes = | |
| MessageFormatAdapter::getArgTypeList(*(const MessageFormat*)fmt, count); | |
| // Allocate at least one element. Allocating an array of length | |
| // zero causes problems on some platforms (e.g. Win32). | |
| Formattable* args = new Formattable[count ? count : 1]; | |
| // iterate through the vararg list, and get the arguments out | |
| for(int32_t i = 0; i < count; ++i) { | |
| UChar *stringVal; | |
| double tDouble=0; | |
| int32_t tInt =0; | |
| int64_t tInt64 = 0; | |
| UDate tempDate = 0; | |
| switch(argTypes[i]) { | |
| case Formattable::kDate: | |
| tempDate = va_arg(ap, UDate); | |
| args[i].setDate(tempDate); | |
| break; | |
| case Formattable::kDouble: | |
| tDouble =va_arg(ap, double); | |
| args[i].setDouble(tDouble); | |
| break; | |
| case Formattable::kLong: | |
| tInt = va_arg(ap, int32_t); | |
| args[i].setLong(tInt); | |
| break; | |
| case Formattable::kInt64: | |
| tInt64 = va_arg(ap, int64_t); | |
| args[i].setInt64(tInt64); | |
| break; | |
| case Formattable::kString: | |
| // For some reason, a temporary is needed | |
| stringVal = va_arg(ap, UChar*); | |
| if(stringVal){ | |
| args[i].setString(UnicodeString(stringVal)); | |
| }else{ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| break; | |
| case Formattable::kArray: | |
| // throw away this argument | |
| // this is highly platform-dependent, and probably won't work | |
| // so, if you try to skip arguments in the list (and not use them) | |
| // you'll probably crash | |
| va_arg(ap, int); | |
| break; | |
| case Formattable::kObject: | |
| // Unused argument number. Read and ignore a pointer argument. | |
| va_arg(ap, void*); | |
| break; | |
| default: | |
| // Unknown/unsupported argument type. | |
| U_ASSERT(FALSE); | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| break; | |
| } | |
| } | |
| UnicodeString resultStr; | |
| FieldPosition fieldPosition(0); | |
| /* format the message */ | |
| ((const MessageFormat*)fmt)->format(args,count,resultStr,fieldPosition,*status); | |
| delete[] args; | |
| if(U_FAILURE(*status)){ | |
| return -1; | |
| } | |
| return resultStr.extract(result, resultLength, *status); | |
| } | |
| U_CAPI void | |
| umsg_parse( const UMessageFormat *fmt, | |
| const UChar *source, | |
| int32_t sourceLength, | |
| int32_t *count, | |
| UErrorCode *status, | |
| ...) | |
| { | |
| va_list ap; | |
| //argument checking defered to last method call umsg_vparse which | |
| //saves time when arguments are valid and we dont care when arguments are not | |
| //since we return an error anyway | |
| // start vararg processing | |
| va_start(ap, status); | |
| umsg_vparse(fmt,source,sourceLength,count,ap,status); | |
| // end vararg processing | |
| va_end(ap); | |
| } | |
| U_CAPI void U_EXPORT2 | |
| umsg_vparse(const UMessageFormat *fmt, | |
| const UChar *source, | |
| int32_t sourceLength, | |
| int32_t *count, | |
| va_list ap, | |
| UErrorCode *status) | |
| { | |
| //check arguments | |
| if(status==NULL||U_FAILURE(*status)) | |
| { | |
| return; | |
| } | |
| if(fmt==NULL||source==NULL || sourceLength<-1 || count==NULL){ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| return; | |
| } | |
| if(sourceLength==-1){ | |
| sourceLength=u_strlen(source); | |
| } | |
| UnicodeString srcString(source,sourceLength); | |
| Formattable *args = ((const MessageFormat*)fmt)->parse(srcString,*count,*status); | |
| UDate *aDate; | |
| double *aDouble; | |
| UChar *aString; | |
| int32_t* aInt; | |
| int64_t* aInt64; | |
| UnicodeString temp; | |
| int len =0; | |
| // assign formattables to varargs | |
| for(int32_t i = 0; i < *count; i++) { | |
| switch(args[i].getType()) { | |
| case Formattable::kDate: | |
| aDate = va_arg(ap, UDate*); | |
| if(aDate){ | |
| *aDate = args[i].getDate(); | |
| }else{ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| break; | |
| case Formattable::kDouble: | |
| aDouble = va_arg(ap, double*); | |
| if(aDouble){ | |
| *aDouble = args[i].getDouble(); | |
| }else{ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| break; | |
| case Formattable::kLong: | |
| aInt = va_arg(ap, int32_t*); | |
| if(aInt){ | |
| *aInt = (int32_t) args[i].getLong(); | |
| }else{ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| break; | |
| case Formattable::kInt64: | |
| aInt64 = va_arg(ap, int64_t*); | |
| if(aInt64){ | |
| *aInt64 = args[i].getInt64(); | |
| }else{ | |
| *status=U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| break; | |
| case Formattable::kString: | |
| aString = va_arg(ap, UChar*); | |
| if(aString){ | |
| args[i].getString(temp); | |
| len = temp.length(); | |
| temp.extract(0,len,aString); | |
| aString[len]=0; | |
| }else{ | |
| *status= U_ILLEGAL_ARGUMENT_ERROR; | |
| } | |
| break; | |
| case Formattable::kObject: | |
| // This will never happen because MessageFormat doesn't | |
| // support kObject. When MessageFormat is changed to | |
| // understand MeasureFormats, modify this code to do the | |
| // right thing. [alan] | |
| U_ASSERT(FALSE); | |
| break; | |
| // better not happen! | |
| case Formattable::kArray: | |
| U_ASSERT(FALSE); | |
| break; | |
| } | |
| } | |
| // clean up | |
| delete [] args; | |
| } | |
| #define SINGLE_QUOTE ((UChar)0x0027) | |
| #define CURLY_BRACE_LEFT ((UChar)0x007B) | |
| #define CURLY_BRACE_RIGHT ((UChar)0x007D) | |
| #define STATE_INITIAL 0 | |
| #define STATE_SINGLE_QUOTE 1 | |
| #define STATE_IN_QUOTE 2 | |
| #define STATE_MSG_ELEMENT 3 | |
| #define MAppend(c) if (len < destCapacity) dest[len++] = c; else len++ | |
| int32_t umsg_autoQuoteApostrophe(const UChar* pattern, | |
| int32_t patternLength, | |
| UChar* dest, | |
| int32_t destCapacity, | |
| UErrorCode* ec) | |
| { | |
| int32_t state = STATE_INITIAL; | |
| int32_t braceCount = 0; | |
| int32_t len = 0; | |
| if (ec == NULL || U_FAILURE(*ec)) { | |
| return -1; | |
| } | |
| if (pattern == NULL || patternLength < -1 || (dest == NULL && destCapacity > 0)) { | |
| *ec = U_ILLEGAL_ARGUMENT_ERROR; | |
| return -1; | |
| } | |
| U_ASSERT(destCapacity >= 0); | |
| if (patternLength == -1) { | |
| patternLength = u_strlen(pattern); | |
| } | |
| for (int i = 0; i < patternLength; ++i) { | |
| UChar c = pattern[i]; | |
| switch (state) { | |
| case STATE_INITIAL: | |
| switch (c) { | |
| case SINGLE_QUOTE: | |
| state = STATE_SINGLE_QUOTE; | |
| break; | |
| case CURLY_BRACE_LEFT: | |
| state = STATE_MSG_ELEMENT; | |
| ++braceCount; | |
| break; | |
| } | |
| break; | |
| case STATE_SINGLE_QUOTE: | |
| switch (c) { | |
| case SINGLE_QUOTE: | |
| state = STATE_INITIAL; | |
| break; | |
| case CURLY_BRACE_LEFT: | |
| case CURLY_BRACE_RIGHT: | |
| state = STATE_IN_QUOTE; | |
| break; | |
| default: | |
| MAppend(SINGLE_QUOTE); | |
| state = STATE_INITIAL; | |
| break; | |
| } | |
| break; | |
| case STATE_IN_QUOTE: | |
| switch (c) { | |
| case SINGLE_QUOTE: | |
| state = STATE_INITIAL; | |
| break; | |
| } | |
| break; | |
| case STATE_MSG_ELEMENT: | |
| switch (c) { | |
| case CURLY_BRACE_LEFT: | |
| ++braceCount; | |
| break; | |
| case CURLY_BRACE_RIGHT: | |
| if (--braceCount == 0) { | |
| state = STATE_INITIAL; | |
| } | |
| break; | |
| } | |
| break; | |
| default: // Never happens. | |
| break; | |
| } | |
| U_ASSERT(len >= 0); | |
| MAppend(c); | |
| } | |
| // End of scan | |
| if (state == STATE_SINGLE_QUOTE || state == STATE_IN_QUOTE) { | |
| MAppend(SINGLE_QUOTE); | |
| } | |
| return u_terminateUChars(dest, destCapacity, len, ec); | |
| } | |
| #endif /* #if !UCONFIG_NO_FORMATTING */ |