// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
*******************************************************************************
*
* Copyright (C) 1999-2012, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
* file name: umsg.cpp
* encoding: UTF-8
* 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!=0) || patternLength<-1) {
*status=U_ILLEGAL_ARGUMENT_ERROR;
return ;
}
if(parseError==NULL){
parseError = &tErr;
}
// UnicodeString(pattern, -1) calls u_strlen().
((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(FieldPosition::DONT_CARE);
/* 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 */