src/third_party/icu/source/i18n/umsg.cpp

   1 /*
   2 *******************************************************************************
   3 *
   4 *   Copyright (C) 1999-2012, International Business Machines
   5 *   Corporation and others.  All Rights Reserved.
   6 *
   7 *******************************************************************************
   8 *   file name:  umsg.cpp
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 * This is a C wrapper to MessageFormat C++ API.
  14 *
  15 *   Change history:
  16 *
  17 *   08/5/2001  Ram         Added C wrappers for C++ API. Changed implementation of old API's
  18 *                          Removed pattern parser.
  19 *
  20 */
  21
  22 #include "unicode/utypes.h"
  23
  24 #if !UCONFIG_NO_FORMATTING
  25
  26 #include "unicode/umsg.h"
  27 #include "unicode/ustring.h"
  28 #include "unicode/fmtable.h"
  29 #include "unicode/msgfmt.h"
  30 #include "unicode/unistr.h"
  31 #include "cpputils.h"
  32 #include "uassert.h"
  33 #include "ustr_imp.h"
  34
  35 U_NAMESPACE_BEGIN
  36 /**
  37  * This class isolates our access to private internal methods of
  38  * MessageFormat.  It is never instantiated; it exists only for C++
  39  * access management.
  40  */
  41 class MessageFormatAdapter {
  42 public:
  43     static const Formattable::Type* getArgTypeList(const MessageFormat& m,
  44                                                    int32_t& count);
  45     static UBool hasArgTypeConflicts(const MessageFormat& m) {
  46         return m.hasArgTypeConflicts;
  47     }
  48 };
  49 const Formattable::Type*
  50 MessageFormatAdapter::getArgTypeList(const MessageFormat& m,
  51                                      int32_t& count) {
  52     return m.getArgTypeList(count);
  53 }
  54 U_NAMESPACE_END
  55
  56 U_NAMESPACE_USE
  57
  58 U_CAPI int32_t
  59 u_formatMessage(const char  *locale,
  60                 const UChar *pattern,
  61                 int32_t     patternLength,
  62                 UChar       *result,
  63                 int32_t     resultLength,
  64                 UErrorCode  *status,
  65                 ...)
  66 {
  67     va_list    ap;
  68     int32_t actLen;
  69     //argument checking defered to subsequent method calls
  70     // start vararg processing
  71     va_start(ap, status);
  72
  73     actLen = u_vformatMessage(locale,pattern,patternLength,result,resultLength,ap,status);
  74     // end vararg processing
  75     va_end(ap);
  76
  77     return actLen;
  78 }
  79
  80 U_CAPI int32_t U_EXPORT2
  81 u_vformatMessage(   const char  *locale,
  82                     const UChar *pattern,
  83                     int32_t     patternLength,
  84                     UChar       *result,
  85                     int32_t     resultLength,
  86                     va_list     ap,
  87                     UErrorCode  *status)
  88
  89 {
  90     //argument checking defered to subsequent method calls
  91     UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,NULL,status);
  92     int32_t retVal = umsg_vformat(fmt,result,resultLength,ap,status);
  93     umsg_close(fmt);
  94     return retVal;
  95 }
  96
  97 U_CAPI int32_t
  98 u_formatMessageWithError(const char *locale,
  99                         const UChar *pattern,
 100                         int32_t     patternLength,
 101                         UChar       *result,
 102                         int32_t     resultLength,
 103                         UParseError *parseError,
 104                         UErrorCode  *status,
 105                         ...)
 106 {
 107     va_list    ap;
 108     int32_t actLen;
 109     //argument checking defered to subsequent method calls
 110     // start vararg processing
 111     va_start(ap, status);
 112
 113     actLen = u_vformatMessageWithError(locale,pattern,patternLength,result,resultLength,parseError,ap,status);
 114
 115     // end vararg processing
 116     va_end(ap);
 117     return actLen;
 118 }
 119
 120 U_CAPI int32_t U_EXPORT2
 121 u_vformatMessageWithError(  const char  *locale,
 122                             const UChar *pattern,
 123                             int32_t     patternLength,
 124                             UChar       *result,
 125                             int32_t     resultLength,
 126                             UParseError *parseError,
 127                             va_list     ap,
 128                             UErrorCode  *status)
 129
 130 {
 131     //argument checking defered to subsequent method calls
 132     UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,parseError,status);
 133     int32_t retVal = umsg_vformat(fmt,result,resultLength,ap,status);
 134     umsg_close(fmt);
 135     return retVal;
 136 }
 137
 138
 139 // For parse, do the reverse of format:
 140 //  1. Call through to the C++ APIs
 141 //  2. Just assume the user passed in enough arguments.
 142 //  3. Iterate through each formattable returned, and assign to the arguments
 143 U_CAPI void
 144 u_parseMessage( const char   *locale,
 145                 const UChar  *pattern,
 146                 int32_t      patternLength,
 147                 const UChar  *source,
 148                 int32_t      sourceLength,
 149                 UErrorCode   *status,
 150                 ...)
 151 {
 152     va_list    ap;
 153     //argument checking defered to subsequent method calls
 154
 155     // start vararg processing
 156     va_start(ap, status);
 157
 158     u_vparseMessage(locale,pattern,patternLength,source,sourceLength,ap,status);
 159     // end vararg processing
 160     va_end(ap);
 161 }
 162
 163 U_CAPI void U_EXPORT2
 164 u_vparseMessage(const char  *locale,
 165                 const UChar *pattern,
 166                 int32_t     patternLength,
 167                 const UChar *source,
 168                 int32_t     sourceLength,
 169                 va_list     ap,
 170                 UErrorCode  *status)
 171 {
 172     //argument checking defered to subsequent method calls
 173     UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,NULL,status);
 174     int32_t count = 0;
 175     umsg_vparse(fmt,source,sourceLength,&count,ap,status);
 176     umsg_close(fmt);
 177 }
 178
 179 U_CAPI void
 180 u_parseMessageWithError(const char  *locale,
 181                         const UChar *pattern,
 182                         int32_t     patternLength,
 183                         const UChar *source,
 184                         int32_t     sourceLength,
 185                         UParseError *error,
 186                         UErrorCode  *status,
 187                         ...)
 188 {
 189     va_list    ap;
 190
 191     //argument checking defered to subsequent method calls
 192
 193     // start vararg processing
 194     va_start(ap, status);
 195
 196     u_vparseMessageWithError(locale,pattern,patternLength,source,sourceLength,ap,error,status);
 197     // end vararg processing
 198     va_end(ap);
 199 }
 200 U_CAPI void U_EXPORT2
 201 u_vparseMessageWithError(const char  *locale,
 202                          const UChar *pattern,
 203                          int32_t     patternLength,
 204                          const UChar *source,
 205                          int32_t     sourceLength,
 206                          va_list     ap,
 207                          UParseError *error,
 208                          UErrorCode* status)
 209 {
 210     //argument checking defered to subsequent method calls
 211     UMessageFormat *fmt = umsg_open(pattern,patternLength,locale,error,status);
 212     int32_t count = 0;
 213     umsg_vparse(fmt,source,sourceLength,&count,ap,status);
 214     umsg_close(fmt);
 215 }
 216 //////////////////////////////////////////////////////////////////////////////////
 217 //
 218 //  Message format C API
 219 //
 220 /////////////////////////////////////////////////////////////////////////////////
 221
 222
 223 U_CAPI UMessageFormat* U_EXPORT2
 224 umsg_open(  const UChar     *pattern,
 225             int32_t         patternLength,
 226             const  char     *locale,
 227             UParseError     *parseError,
 228             UErrorCode      *status)
 229 {
 230     //check arguments
 231     if(status==NULL || U_FAILURE(*status))
 232     {
 233       return 0;
 234     }
 235     if(pattern==NULL||patternLength<-1){
 236         *status=U_ILLEGAL_ARGUMENT_ERROR;
 237         return 0;
 238     }
 239
 240     UParseError tErr;
 241     if(parseError==NULL)
 242     {
 243         parseError = &tErr;
 244     }
 245
 246     int32_t len = (patternLength == -1 ? u_strlen(pattern) : patternLength);
 247     UnicodeString patString(patternLength == -1, pattern, len);
 248
 249     MessageFormat* retVal = new MessageFormat(patString,Locale(locale),*parseError,*status);
 250     if(retVal == NULL) {
 251         *status = U_MEMORY_ALLOCATION_ERROR;
 252         return NULL;
 253     }
 254     if (U_SUCCESS(*status) && MessageFormatAdapter::hasArgTypeConflicts(*retVal)) {
 255         *status = U_ARGUMENT_TYPE_MISMATCH;
 256     }
 257     return (UMessageFormat*)retVal;
 258 }
 259
 260 U_CAPI void U_EXPORT2
 261 umsg_close(UMessageFormat* format)
 262 {
 263     //check arguments
 264     if(format==NULL){
 265         return;
 266     }
 267     delete (MessageFormat*) format;
 268 }
 269
 270 U_CAPI UMessageFormat U_EXPORT2
 271 umsg_clone(const UMessageFormat *fmt,
 272            UErrorCode *status)
 273 {
 274     //check arguments
 275     if(status==NULL || U_FAILURE(*status)){
 276         return NULL;
 277     }
 278     if(fmt==NULL){
 279         *status = U_ILLEGAL_ARGUMENT_ERROR;
 280         return NULL;
 281     }
 282     UMessageFormat retVal = (UMessageFormat)((MessageFormat*)fmt)->clone();
 283     if(retVal == 0) {
 284         *status = U_MEMORY_ALLOCATION_ERROR;
 285         return 0;
 286     }
 287     return retVal;
 288 }
 289
 290 U_CAPI void  U_EXPORT2
 291 umsg_setLocale(UMessageFormat *fmt, const char* locale)
 292 {
 293     //check arguments
 294     if(fmt==NULL){
 295         return;
 296     }
 297     ((MessageFormat*)fmt)->setLocale(Locale(locale));
 298 }
 299
 300 U_CAPI const char*  U_EXPORT2
 301 umsg_getLocale(const UMessageFormat *fmt)
 302 {
 303     //check arguments
 304     if(fmt==NULL){
 305         return "";
 306     }
 307     return ((const MessageFormat*)fmt)->getLocale().getName();
 308 }
 309
 310 U_CAPI void  U_EXPORT2
 311 umsg_applyPattern(UMessageFormat *fmt,
 312                            const UChar* pattern,
 313                            int32_t patternLength,
 314                            UParseError* parseError,
 315                            UErrorCode* status)
 316 {
 317     //check arguments
 318     UParseError tErr;
 319     if(status ==NULL||U_FAILURE(*status)){
 320         return ;
 321     }
 322     if(fmt==NULL||pattern==NULL||patternLength<-1){
 323         *status=U_ILLEGAL_ARGUMENT_ERROR;
 324         return ;
 325     }
 326
 327     if(parseError==NULL){
 328       parseError = &tErr;
 329     }
 330     if(patternLength<-1){
 331         patternLength=u_strlen(pattern);
 332     }
 333
 334     ((MessageFormat*)fmt)->applyPattern(UnicodeString(pattern,patternLength),*parseError,*status);
 335 }
 336
 337 U_CAPI int32_t  U_EXPORT2
 338 umsg_toPattern(const UMessageFormat *fmt,
 339                UChar* result,
 340                int32_t resultLength,
 341                UErrorCode* status)
 342 {
 343     //check arguments
 344     if(status ==NULL||U_FAILURE(*status)){
 345         return -1;
 346     }
 347     if(fmt==NULL||resultLength<0 || (resultLength>0 && result==0)){
 348         *status=U_ILLEGAL_ARGUMENT_ERROR;
 349         return -1;
 350     }
 351
 352
 353     UnicodeString res;
 354     if(!(result==NULL && resultLength==0)) {
 355         // NULL destination for pure preflighting: empty dummy string
 356         // otherwise, alias the destination buffer
 357         res.setTo(result, 0, resultLength);
 358     }
 359     ((const MessageFormat*)fmt)->toPattern(res);
 360     return res.extract(result, resultLength, *status);
 361 }
 362
 363 U_CAPI int32_t
 364 umsg_format(    const UMessageFormat *fmt,
 365                 UChar          *result,
 366                 int32_t        resultLength,
 367                 UErrorCode     *status,
 368                 ...)
 369 {
 370     va_list    ap;
 371     int32_t actLen;
 372     //argument checking defered to last method call umsg_vformat which
 373     //saves time when arguments are valid and we dont care when arguments are not
 374     //since we return an error anyway
 375
 376
 377     // start vararg processing
 378     va_start(ap, status);
 379
 380     actLen = umsg_vformat(fmt,result,resultLength,ap,status);
 381
 382     // end vararg processing
 383     va_end(ap);
 384
 385     return actLen;
 386 }
 387
 388 U_CAPI int32_t U_EXPORT2
 389 umsg_vformat(   const UMessageFormat *fmt,
 390                 UChar          *result,
 391                 int32_t        resultLength,
 392                 va_list        ap,
 393                 UErrorCode     *status)
 394 {
 395     //check arguments
 396     if(status==0 || U_FAILURE(*status))
 397     {
 398         return -1;
 399     }
 400     if(fmt==NULL||resultLength<0 || (resultLength>0 && result==0)) {
 401         *status=U_ILLEGAL_ARGUMENT_ERROR;
 402         return -1;
 403     }
 404
 405     int32_t count =0;
 406     const Formattable::Type* argTypes =
 407         MessageFormatAdapter::getArgTypeList(*(const MessageFormat*)fmt, count);
 408     // Allocate at least one element.  Allocating an array of length
 409     // zero causes problems on some platforms (e.g. Win32).
 410     Formattable* args = new Formattable[count ? count : 1];
 411
 412     // iterate through the vararg list, and get the arguments out
 413     for(int32_t i = 0; i < count; ++i) {
 414
 415         UChar *stringVal;
 416         double tDouble=0;
 417         int32_t tInt =0;
 418         int64_t tInt64 = 0;
 419         UDate tempDate = 0;
 420         switch(argTypes[i]) {
 421         case Formattable::kDate:
 422             tempDate = va_arg(ap, UDate);
 423             args[i].setDate(tempDate);
 424             break;
 425
 426         case Formattable::kDouble:
 427             tDouble =va_arg(ap, double);
 428             args[i].setDouble(tDouble);
 429             break;
 430
 431         case Formattable::kLong:
 432             tInt = va_arg(ap, int32_t);
 433             args[i].setLong(tInt);
 434             break;
 435
 436         case Formattable::kInt64:
 437             tInt64 = va_arg(ap, int64_t);
 438             args[i].setInt64(tInt64);
 439             break;
 440
 441         case Formattable::kString:
 442             // For some reason, a temporary is needed
 443             stringVal = va_arg(ap, UChar*);
 444             if(stringVal){
 445                 args[i].setString(UnicodeString(stringVal));
 446             }else{
 447                 *status=U_ILLEGAL_ARGUMENT_ERROR;
 448             }
 449             break;
 450
 451         case Formattable::kArray:
 452             // throw away this argument
 453             // this is highly platform-dependent, and probably won't work
 454             // so, if you try to skip arguments in the list (and not use them)
 455             // you'll probably crash
 456             va_arg(ap, int);
 457             break;
 458
 459         case Formattable::kObject:
 460             // Unused argument number. Read and ignore a pointer argument.
 461             va_arg(ap, void*);
 462             break;
 463
 464         default:
 465             // Unknown/unsupported argument type.
 466             U_ASSERT(FALSE);
 467             *status=U_ILLEGAL_ARGUMENT_ERROR;
 468             break;
 469         }
 470     }
 471     UnicodeString resultStr;
 472     FieldPosition fieldPosition(0);
 473
 474     /* format the message */
 475     ((const MessageFormat*)fmt)->format(args,count,resultStr,fieldPosition,*status);
 476
 477     delete[] args;
 478
 479     if(U_FAILURE(*status)){
 480         return -1;
 481     }
 482
 483     return resultStr.extract(result, resultLength, *status);
 484 }
 485
 486 U_CAPI void
 487 umsg_parse( const UMessageFormat *fmt,
 488             const UChar    *source,
 489             int32_t        sourceLength,
 490             int32_t        *count,
 491             UErrorCode     *status,
 492             ...)
 493 {
 494     va_list    ap;
 495     //argument checking defered to last method call umsg_vparse which
 496     //saves time when arguments are valid and we dont care when arguments are not
 497     //since we return an error anyway
 498
 499     // start vararg processing
 500     va_start(ap, status);
 501
 502     umsg_vparse(fmt,source,sourceLength,count,ap,status);
 503
 504     // end vararg processing
 505     va_end(ap);
 506 }
 507
 508 U_CAPI void U_EXPORT2
 509 umsg_vparse(const UMessageFormat *fmt,
 510             const UChar    *source,
 511             int32_t        sourceLength,
 512             int32_t        *count,
 513             va_list        ap,
 514             UErrorCode     *status)
 515 {
 516     //check arguments
 517     if(status==NULL||U_FAILURE(*status))
 518     {
 519         return;
 520     }
 521     if(fmt==NULL||source==NULL || sourceLength<-1 || count==NULL){
 522         *status=U_ILLEGAL_ARGUMENT_ERROR;
 523         return;
 524     }
 525     if(sourceLength==-1){
 526         sourceLength=u_strlen(source);
 527     }
 528
 529     UnicodeString srcString(source,sourceLength);
 530     Formattable *args = ((const MessageFormat*)fmt)->parse(srcString,*count,*status);
 531     UDate *aDate;
 532     double *aDouble;
 533     UChar *aString;
 534     int32_t* aInt;
 535     int64_t* aInt64;
 536     UnicodeString temp;
 537     int len =0;
 538     // assign formattables to varargs
 539     for(int32_t i = 0; i < *count; i++) {
 540         switch(args[i].getType()) {
 541
 542         case Formattable::kDate:
 543             aDate = va_arg(ap, UDate*);
 544             if(aDate){
 545                 *aDate = args[i].getDate();
 546             }else{
 547                 *status=U_ILLEGAL_ARGUMENT_ERROR;
 548             }
 549             break;
 550
 551         case Formattable::kDouble:
 552             aDouble = va_arg(ap, double*);
 553             if(aDouble){
 554                 *aDouble = args[i].getDouble();
 555             }else{
 556                 *status=U_ILLEGAL_ARGUMENT_ERROR;
 557             }
 558             break;
 559
 560         case Formattable::kLong:
 561             aInt = va_arg(ap, int32_t*);
 562             if(aInt){
 563                 *aInt = (int32_t) args[i].getLong();
 564             }else{
 565                 *status=U_ILLEGAL_ARGUMENT_ERROR;
 566             }
 567             break;
 568
 569         case Formattable::kInt64:
 570             aInt64 = va_arg(ap, int64_t*);
 571             if(aInt64){
 572                 *aInt64 = args[i].getInt64();
 573             }else{
 574                 *status=U_ILLEGAL_ARGUMENT_ERROR;
 575             }
 576             break;
 577
 578         case Formattable::kString:
 579             aString = va_arg(ap, UChar*);
 580             if(aString){
 581                 args[i].getString(temp);
 582                 len = temp.length();
 583                 temp.extract(0,len,aString);
 584                 aString[len]=0;
 585             }else{
 586                 *status= U_ILLEGAL_ARGUMENT_ERROR;
 587             }
 588             break;
 589
 590         case Formattable::kObject:
 591             // This will never happen because MessageFormat doesn't
 592             // support kObject.  When MessageFormat is changed to
 593             // understand MeasureFormats, modify this code to do the
 594             // right thing. [alan]
 595             U_ASSERT(FALSE);
 596             break;
 597
 598         // better not happen!
 599         case Formattable::kArray:
 600             U_ASSERT(FALSE);
 601             break;
 602         }
 603     }
 604
 605     // clean up
 606     delete [] args;
 607 }
 608
 609 #define SINGLE_QUOTE      ((UChar)0x0027)
 610 #define CURLY_BRACE_LEFT  ((UChar)0x007B)
 611 #define CURLY_BRACE_RIGHT ((UChar)0x007D)
 612
 613 #define STATE_INITIAL 0
 614 #define STATE_SINGLE_QUOTE 1
 615 #define STATE_IN_QUOTE 2
 616 #define STATE_MSG_ELEMENT 3
 617
 618 #define MAppend(c) if (len < destCapacity) dest[len++] = c; else len++
 619
 620 int32_t umsg_autoQuoteApostrophe(const UChar* pattern,
 621                  int32_t patternLength,
 622                  UChar* dest,
 623                  int32_t destCapacity,
 624                  UErrorCode* ec)
 625 {
 626     int32_t state = STATE_INITIAL;
 627     int32_t braceCount = 0;
 628     int32_t len = 0;
 629
 630     if (ec == NULL || U_FAILURE(*ec)) {
 631         return -1;
 632     }
 633
 634     if (pattern == NULL || patternLength < -1 || (dest == NULL && destCapacity > 0)) {
 635         *ec = U_ILLEGAL_ARGUMENT_ERROR;
 636         return -1;
 637     }
 638     U_ASSERT(destCapacity >= 0);
 639
 640     if (patternLength == -1) {
 641         patternLength = u_strlen(pattern);
 642     }
 643
 644     for (int i = 0; i < patternLength; ++i) {
 645         UChar c = pattern[i];
 646         switch (state) {
 647         case STATE_INITIAL:
 648             switch (c) {
 649             case SINGLE_QUOTE:
 650                 state = STATE_SINGLE_QUOTE;
 651                 break;
 652             case CURLY_BRACE_LEFT:
 653                 state = STATE_MSG_ELEMENT;
 654                 ++braceCount;
 655                 break;
 656             }
 657             break;
 658
 659         case STATE_SINGLE_QUOTE:
 660             switch (c) {
 661             case SINGLE_QUOTE:
 662                 state = STATE_INITIAL;
 663                 break;
 664             case CURLY_BRACE_LEFT:
 665             case CURLY_BRACE_RIGHT:
 666                 state = STATE_IN_QUOTE;
 667                 break;
 668             default:
 669                 MAppend(SINGLE_QUOTE);
 670                 state = STATE_INITIAL;
 671                 break;
 672             }
 673         break;
 674
 675         case STATE_IN_QUOTE:
 676             switch (c) {
 677             case SINGLE_QUOTE:
 678                 state = STATE_INITIAL;
 679                 break;
 680             }
 681             break;
 682
 683         case STATE_MSG_ELEMENT:
 684             switch (c) {
 685             case CURLY_BRACE_LEFT:
 686                 ++braceCount;
 687                 break;
 688             case CURLY_BRACE_RIGHT:
 689                 if (--braceCount == 0) {
 690                     state = STATE_INITIAL;
 691                 }
 692                 break;
 693             }
 694             break;
 695
 696         default: // Never happens.
 697             break;
 698         }
 699
 700         U_ASSERT(len >= 0);
 701         MAppend(c);
 702     }
 703
 704     // End of scan
 705     if (state == STATE_SINGLE_QUOTE || state == STATE_IN_QUOTE) {
 706         MAppend(SINGLE_QUOTE);
 707     }
 708
 709     return u_terminateUChars(dest, destCapacity, len, ec);
 710 }
 711
 712 #endif /* #if !UCONFIG_NO_FORMATTING */