icuSources/i18n/umsg.cpp

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