[apple/icu.git] / icuSources / i18n / umsg.cpp

// © 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.
            UPRV_UNREACHABLE;
        }
    }
    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]
            UPRV_UNREACHABLE;

        // better not happen!
        case Formattable::kArray:
            UPRV_UNREACHABLE;
        }
    }

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