The Tor Browser: intl/icu/source/i18n/umsg.cpp@6474c204b198 (annotated)

intl/icu/source/i18n/umsg.cpp@6474c204b198 (annotated)

intl/icu/source/i18n/umsg.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /*
 *******************************************************************************
 *
 *   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 "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 */

The Tor Browser / annotate

intl/icu/source/i18n/umsg.cpp@6474c204b198 (annotated)

intl/icu/source/i18n/umsg.cpp