LESwaps.h		LESwaps.h
	/*		/*
	*		*
	* (C) Copyright IBM Corp. 1998-2008 - All Rights Reserved		* (C) Copyright IBM Corp. 1998-2010 - All Rights Reserved
	*		*
	*/		*/
	#ifndef __LESWAPS_H		#ifndef __LESWAPS_H
	#define __LESWAPS_H		#define __LESWAPS_H
	#include "LETypes.h"		#include "LETypes.h"
	/**		/**
	* \file		* \file
	skipping to change at line 26		skipping to change at line 25
	*/		*/
	U_NAMESPACE_BEGIN		U_NAMESPACE_BEGIN
	/**		/**
	* A convenience macro which invokes the swapWord member function		* A convenience macro which invokes the swapWord member function
	* from a concise call.		* from a concise call.
	*		*
	* @stable ICU 2.8		* @stable ICU 2.8
	*/		*/
	#define SWAPW(value) LESwaps::swapWord((const le_uint16 &) (value))		#define SWAPW(value) LESwaps::swapWord((le_uint16)(value))
	/**		/**
	* A convenience macro which invokes the swapLong member function		* A convenience macro which invokes the swapLong member function
	* from a concise call.		* from a concise call.
	*		*
	* @stable ICU 2.8		* @stable ICU 2.8
	*/		*/
	#define SWAPL(value) LESwaps::swapLong((const le_uint32 &) (value))		#define SWAPL(value) LESwaps::swapLong((le_uint32)(value))
	/**		/**
	* This class is used to access data which stored in big endian order		* This class is used to access data which stored in big endian order
	* regardless of the conventions of the platform.		* regardless of the conventions of the platform.
	*		*
	* All methods are static and inline in an attempt to induce the compiler		* All methods are static and inline in an attempt to induce the compiler
	* to do most of the calculations at compile time.		* to do most of the calculations at compile time.
	*		*
	* @stable ICU 2.8		* @stable ICU 2.8
	*/		*/
	skipping to change at line 58		skipping to change at line 57
	/**		/**
	* This method does the byte swap required on little endian platforms		* This method does the byte swap required on little endian platforms
	* to correctly access a (16-bit) word.		* to correctly access a (16-bit) word.
	*		*
	* @param value - the word to be byte swapped		* @param value - the word to be byte swapped
	*		*
	* @return the byte swapped word		* @return the byte swapped word
	*		*
	* @stable ICU 2.8		* @stable ICU 2.8
	*/		*/
	static le_uint16 swapWord(const le_uint16 &value)		static le_uint16 swapWord(le_uint16 value)
	{		{
	const le_uint8 *p = (const le_uint8 *) &value;		return (le_uint16)((value << 8) | (value >> 8));
	return ((p[0] << 8) + p[1]);
	};		};
	/**		/**
	* This method does the byte swapping required on little endian platfor ms		* This method does the byte swapping required on little endian platfor ms
	* to correctly access a (32-bit) long.		* to correctly access a (32-bit) long.
	*		*
	* @param value - the long to be byte swapped		* @param value - the long to be byte swapped
	*		*
	* @return the byte swapped long		* @return the byte swapped long
	*		*
	* @stable ICU 2.8		* @stable ICU 2.8
	*/		*/
	static le_uint32 swapLong(const le_uint32 &value)		static le_uint32 swapLong(le_uint32 value)
	{		{
	const le_uint8 *p = (const le_uint8 *) &value;		return (le_uint32)(
			(value << 24) |
	return ((p[0] << 24) + (p[1] << 16) + (p[2] << 8) + p[3]);		((value << 8) & 0xff0000) |
			((value >> 8) & 0xff00) |
			(value >> 24));
	};		};
	private:		private:
	LESwaps() {} // private - forbid instantiation		LESwaps() {} // private - forbid instantiation
	};		};
	U_NAMESPACE_END		U_NAMESPACE_END
	#endif		#endif
End of changes. 8 change blocks.
	12 lines changed or deleted		11 lines changed or added

	bytestream.h		bytestream.h
	skipping to change at line 120		skipping to change at line 120
	*/		*/
	virtual char* GetAppendBuffer(int32_t min_capacity,		virtual char* GetAppendBuffer(int32_t min_capacity,
	int32_t desired_capacity_hint,		int32_t desired_capacity_hint,
	char* scratch, int32_t scratch_capacity,		char* scratch, int32_t scratch_capacity,
	int32_t* result_capacity);		int32_t* result_capacity);
	/**		/**
	* Flush internal buffers.		* Flush internal buffers.
	* Some byte sinks use internal buffers or provide buffering		* Some byte sinks use internal buffers or provide buffering
	* and require calling Flush() at the end of the stream.		* and require calling Flush() at the end of the stream.
			* The ByteSink should be ready for further Append() calls after Flush().
	* The default implementation of Flush() does nothing.		* The default implementation of Flush() does nothing.
	* @stable ICU 4.2		* @stable ICU 4.2
	*/		*/
	virtual void Flush();		virtual void Flush();
	private:		private:
	ByteSink(const ByteSink &); // copy constructor not implemented		ByteSink(const ByteSink &); // copy constructor not implemented
	ByteSink &operator=(const ByteSink &); // assignment operator not impleme nted		ByteSink &operator=(const ByteSink &); // assignment operator not impleme nted
	};		};
	skipping to change at line 152		skipping to change at line 153
	class U_COMMON_API CheckedArrayByteSink : public ByteSink {		class U_COMMON_API CheckedArrayByteSink : public ByteSink {
	public:		public:
	/**		/**
	* Constructs a ByteSink that will write to outbuf[0..capacity-1].		* Constructs a ByteSink that will write to outbuf[0..capacity-1].
	* @param outbuf buffer to write to		* @param outbuf buffer to write to
	* @param capacity size of the buffer		* @param capacity size of the buffer
	* @stable ICU 4.2		* @stable ICU 4.2
	*/		*/
	CheckedArrayByteSink(char* outbuf, int32_t capacity);		CheckedArrayByteSink(char* outbuf, int32_t capacity);
	/**		/**
			* Returns the sink to its original state, without modifying the buffer.
			* Useful for reusing both the buffer and the sink for multiple streams.
			* Resets the state to NumberOfBytesWritten()=NumberOfBytesAppended()=0
			* and Overflowed()=FALSE.
			* @return *this
			* @draft ICU 4.6
			*/
			virtual CheckedArrayByteSink& Reset();
			/**
	* Append "bytes[0,n-1]" to this.		* Append "bytes[0,n-1]" to this.
	* @param bytes the pointer to the bytes		* @param bytes the pointer to the bytes
	* @param n the number of bytes; must be non-negative		* @param n the number of bytes; must be non-negative
	* @stable ICU 4.2		* @stable ICU 4.2
	*/		*/
	virtual void Append(const char* bytes, int32_t n);		virtual void Append(const char* bytes, int32_t n);
	/**		/**
	* Returns a writable buffer for appending and writes the buffer's capaci ty to		* Returns a writable buffer for appending and writes the buffer's capaci ty to
	* *result_capacity. For details see the base class documentation.		* *result_capacity. For details see the base class documentation.
	* @param min_capacity required minimum capacity of the returned buffer;		* @param min_capacity required minimum capacity of the returned buffer;
	skipping to change at line 189		skipping to change at line 199
	* @stable ICU 4.2		* @stable ICU 4.2
	*/		*/
	int32_t NumberOfBytesWritten() const { return size_; }		int32_t NumberOfBytesWritten() const { return size_; }
	/**		/**
	* Returns true if any bytes were discarded, i.e., if there was an		* Returns true if any bytes were discarded, i.e., if there was an
	* attempt to write more than 'capacity' bytes.		* attempt to write more than 'capacity' bytes.
	* @return TRUE if more than 'capacity' bytes were Append()ed		* @return TRUE if more than 'capacity' bytes were Append()ed
	* @stable ICU 4.2		* @stable ICU 4.2
	*/		*/
	UBool Overflowed() const { return overflowed_; }		UBool Overflowed() const { return overflowed_; }
			/**
			* Returns the number of bytes appended to the sink.
			* If Overflowed() then NumberOfBytesAppended()>NumberOfBytesWritten()
			* else they return the same number.
			* @return number of bytes written to the buffer
			* @draft ICU 4.6
			*/
			int32_t NumberOfBytesAppended() const { return appended_; }
	private:		private:
	char* outbuf_;		char* outbuf_;
	const int32_t capacity_;		const int32_t capacity_;
	int32_t size_;		int32_t size_;
	bool overflowed_;		int32_t appended_;
			UBool overflowed_;
	CheckedArrayByteSink(); ///< default constructor not implemented		CheckedArrayByteSink(); ///< default constructor not implemented
	CheckedArrayByteSink(const CheckedArrayByteSink &); ///< copy constructor not implemented		CheckedArrayByteSink(const CheckedArrayByteSink &); ///< copy constructor not implemented
	CheckedArrayByteSink &operator=(const CheckedArrayByteSink &); ///< assig nment operator not implemented		CheckedArrayByteSink &operator=(const CheckedArrayByteSink &); ///< assig nment operator not implemented
	};		};
	#if U_HAVE_STD_STRING		#if U_HAVE_STD_STRING
	/**		/**
	* Implementation of ByteSink that writes to a "string".		* Implementation of ByteSink that writes to a "string".
	* The StringClass is usually instantiated with a std::string.		* The StringClass is usually instantiated with a std::string.
End of changes. 4 change blocks.
	1 lines changed or deleted		20 lines changed or added

	caniter.h		caniter.h
	skipping to change at line 35		skipping to change at line 35
	* @stable ICU 2.4		* @stable ICU 2.4
	*/		*/
	#ifndef CANITER_SKIP_ZEROES		#ifndef CANITER_SKIP_ZEROES
	#define CANITER_SKIP_ZEROES TRUE		#define CANITER_SKIP_ZEROES TRUE
	#endif		#endif
	U_NAMESPACE_BEGIN		U_NAMESPACE_BEGIN
	class Hashtable;		class Hashtable;
	class Normalizer2;		class Normalizer2;
			class Normalizer2Impl;
	/**		/**
	* This class allows one to iterate through all the strings that are canoni cally equivalent to a given		* This class allows one to iterate through all the strings that are canoni cally equivalent to a given
	* string. For example, here are some sample results:		* string. For example, here are some sample results:
	Results for: {LATIN CAPITAL LETTER A WITH RING ABOVE}{LATIN SMALL LETTER D} {COMBINING DOT ABOVE}{COMBINING CEDILLA}		Results for: {LATIN CAPITAL LETTER A WITH RING ABOVE}{LATIN SMALL LETTER D} {COMBINING DOT ABOVE}{COMBINING CEDILLA}
	1: \\u0041\\u030A\\u0064\\u0307\\u0327		1: \\u0041\\u030A\\u0064\\u0307\\u0327
	= {LATIN CAPITAL LETTER A}{COMBINING RING ABOVE}{LATIN SMALL LETTER D}{COM BINING DOT ABOVE}{COMBINING CEDILLA}		= {LATIN CAPITAL LETTER A}{COMBINING RING ABOVE}{LATIN SMALL LETTER D}{COM BINING DOT ABOVE}{COMBINING CEDILLA}
	2: \\u0041\\u030A\\u0064\\u0327\\u0307		2: \\u0041\\u030A\\u0064\\u0327\\u0307
	= {LATIN CAPITAL LETTER A}{COMBINING RING ABOVE}{LATIN SMALL LETTER D}{COM BINING CEDILLA}{COMBINING DOT ABOVE}		= {LATIN CAPITAL LETTER A}{COMBINING RING ABOVE}{LATIN SMALL LETTER D}{COM BINING CEDILLA}{COMBINING DOT ABOVE}
	3: \\u0041\\u030A\\u1E0B\\u0327		3: \\u0041\\u030A\\u1E0B\\u0327
	skipping to change at line 178		skipping to change at line 179
	int32_t *pieces_lengths;		int32_t *pieces_lengths;
	// current is used in iterating to combine pieces		// current is used in iterating to combine pieces
	int32_t *current;		int32_t *current;
	int32_t current_length;		int32_t current_length;
	// transient fields		// transient fields
	UnicodeString buffer;		UnicodeString buffer;
	const Normalizer2 &nfd;		const Normalizer2 &nfd;
			const Normalizer2Impl &nfcImpl;
	// we have a segment, in NFD. Find all the strings that are canonically equivalent to it.		// we have a segment, in NFD. Find all the strings that are canonically equivalent to it.
	UnicodeString *getEquivalents(const UnicodeString &segment, int32_t &re sult_len, UErrorCode &status); //private String[] getEquivalents(String seg ment)		UnicodeString *getEquivalents(const UnicodeString &segment, int32_t &re sult_len, UErrorCode &status); //private String[] getEquivalents(String seg ment)
	//Set getEquivalents2(String segment);		//Set getEquivalents2(String segment);
	Hashtable *getEquivalents2(Hashtable *fillinResult, const UChar *segmen t, int32_t segLen, UErrorCode &status);		Hashtable *getEquivalents2(Hashtable *fillinResult, const UChar *segmen t, int32_t segLen, UErrorCode &status);
	//Hashtable *getEquivalents2(const UnicodeString &segment, int32_t segL en, UErrorCode &status);		//Hashtable *getEquivalents2(const UnicodeString &segment, int32_t segL en, UErrorCode &status);
	/**		/**
	* See if the decomposition of cp2 is at segment starting at segmentPos		* See if the decomposition of cp2 is at segment starting at segmentPos
End of changes. 2 change blocks.
	0 lines changed or deleted		2 lines changed or added

	dcfmtsym.h		dcfmtsym.h
	skipping to change at line 295		skipping to change at line 295
	/**		/**
	* Initializes the symbols from the LocaleElements resource bundle.		* Initializes the symbols from the LocaleElements resource bundle.
	* Note: The organization of LocaleElements badly needs to be		* Note: The organization of LocaleElements badly needs to be
	* cleaned up.		* cleaned up.
	*		*
	* @param locale The locale to get symbols for.		* @param locale The locale to get symbols for.
	* @param success Input/output parameter, set to success o r		* @param success Input/output parameter, set to success o r
	* failure code upon return.		* failure code upon return.
	* @param useLastResortData determine if use last resort data		* @param useLastResortData determine if use last resort data
	*/		*/
	void initialize(const Locale& locale, UErrorCode& success, UBool useLas		void initialize(const Locale& locale, UErrorCode& success);
	tResortData = FALSE);
	/**
	* Initialize the symbols from the given array of UnicodeStrings.
	* The array must be of the correct size.
	*
	* @param numberElements the number format symbols
	* @param numberElementsLength length of numberElements
	*/
	void initialize(const UChar** numberElements, int32_t *numberElementsSt
	rLen, int32_t numberElementsLength);
	/**		/**
	* Initialize the symbols with default values.		* Initialize the symbols with default values.
	*/		*/
	void initialize();		void initialize();
	void setCurrencyForSymbols();		void setCurrencyForSymbols();
	public:		public:
	/**		/**
End of changes. 1 change blocks.
	12 lines changed or deleted		1 lines changed or added

	fmtable.h		fmtable.h
	skipping to change at line 31		skipping to change at line 31
	/**		/**
	* \file		* \file
	* \brief C++ API: Formattable is a thin wrapper for primitive numeric type s.		* \brief C++ API: Formattable is a thin wrapper for primitive numeric type s.
	*/		*/
	#if !UCONFIG_NO_FORMATTING		#if !UCONFIG_NO_FORMATTING
	U_NAMESPACE_BEGIN		U_NAMESPACE_BEGIN
	class DecimalNumberString;		class CharString;
	class DigitList;		class DigitList;
	/**		/**
	* Formattable objects can be passed to the Format class or		* Formattable objects can be passed to the Format class or
	* its subclasses for formatting. Formattable is a thin wrapper		* its subclasses for formatting. Formattable is a thin wrapper
	* class which interconverts between the primitive numeric types		* class which interconverts between the primitive numeric types
	* (double, long, etc.) as well as UDate and UnicodeString.		* (double, long, etc.) as well as UDate and UnicodeString.
	*		*
	* <p>Internally, a Formattable object is a union of primitive types.		* <p>Internally, a Formattable object is a union of primitive types.
	* As such, it can only store one flavor of data at a time. To		* As such, it can only store one flavor of data at a time. To
	* determine what flavor of data it contains, use the getType method.		* determine what flavor of data it contains, use the getType method.
	skipping to change at line 609		skipping to change at line 609
	* needs to get at the DigitList, if it exists, for		* needs to get at the DigitList, if it exists, for
	* big decimal formatting.		* big decimal formatting.
	* @internal		* @internal
	*/		*/
	DigitList *getDigitList() const { return fDecimalNum;};		DigitList *getDigitList() const { return fDecimalNum;};
	/**		/**
	* Adopt, and set value from, a DigitList		* Adopt, and set value from, a DigitList
	* Internal Function, do not use.		* Internal Function, do not use.
	* @param dl the Digit List to be adopted		* @param dl the Digit List to be adopted
	* @param status reports errors
	* @internal		* @internal
	*/		*/
	void adoptDigitList(DigitList *dl);		void adoptDigitList(DigitList *dl);
	private:		private:
	/**		/**
	* Cleans up the memory for unwanted values. For example, the adopted		* Cleans up the memory for unwanted values. For example, the adopted
	* string or array objects.		* string or array objects.
	*/		*/
	void dispose(void);		void dispose(void);
	skipping to change at line 640		skipping to change at line 639
	UnicodeString* fString;		UnicodeString* fString;
	double fDouble;		double fDouble;
	int64_t fInt64;		int64_t fInt64;
	UDate fDate;		UDate fDate;
	struct {		struct {
	Formattable* fArray;		Formattable* fArray;
	int32_t fCount;		int32_t fCount;
	} fArrayAndCount;		} fArrayAndCount;
	} fValue;		} fValue;
	DecimalNumberString *fDecimalStr;		CharString *fDecimalStr;
	DigitList *fDecimalNum;		DigitList *fDecimalNum;
	Type fType;		Type fType;
	UnicodeString fBogus; // Bogus string when it's needed.		UnicodeString fBogus; // Bogus string when it's needed.
	};		};
	inline UDate Formattable::getDate(UErrorCode& status) const {		inline UDate Formattable::getDate(UErrorCode& status) const {
	if (fType != kDate) {		if (fType != kDate) {
	if (U_SUCCESS(status)) {		if (U_SUCCESS(status)) {
	status = U_INVALID_FORMAT_ERROR;		status = U_INVALID_FORMAT_ERROR;
End of changes. 3 change blocks.
	4 lines changed or deleted		3 lines changed or added

	format.h		format.h
	skipping to change at line 88		skipping to change at line 88
	* and MessageFormat headers for further information.		* and MessageFormat headers for further information.
	* <P>		* <P>
	* If formatting is unsuccessful, a failing UErrorCode is returned when		* If formatting is unsuccessful, a failing UErrorCode is returned when
	* the Format cannot format the type of object, otherwise if there is		* the Format cannot format the type of object, otherwise if there is
	* something illformed about the the Unicode replacement character		* something illformed about the the Unicode replacement character
	* 0xFFFD is returned.		* 0xFFFD is returned.
	* <P>		* <P>
	* If there is no match when parsing, a parse failure UErrorCode is		* If there is no match when parsing, a parse failure UErrorCode is
	* retured for methods which take no ParsePosition. For the method		* retured for methods which take no ParsePosition. For the method
	* that takes a ParsePosition, the index parameter is left unchanged.		* that takes a ParsePosition, the index parameter is left unchanged.
			* The Format class can support either strict or lenient parsing where
			* appropriate (see isLenient, setLenient). By default parsing is
			* lenient in the Format base class; subclasses may have a different
			* default (for example, in NumberFormat, parsing is strict by default
			* for backwards compatibility).
	* <P>		* <P>
	* <em>User subclasses are not supported.</em> While clients may write		* <em>User subclasses are not supported.</em> While clients may write
	* subclasses, such code will not necessarily work and will not be		* subclasses, such code will not necessarily work and will not be
	* guaranteed to work stably from release to release.		* guaranteed to work stably from release to release.
	*/		*/
	class U_I18N_API Format : public UObject {		class U_I18N_API Format : public UObject {
	public:		public:
	/** Destructor		/** Destructor
	* @stable ICU 2.4		* @stable ICU 2.4
	skipping to change at line 242		skipping to change at line 247
	* @param result Formattable to be set to the parse result.		* @param result Formattable to be set to the parse result.
	* If parse fails, return contents are undefined.		* If parse fails, return contents are undefined.
	* @param status Output param to be filled with success/failure		* @param status Output param to be filled with success/failure
	* result code.		* result code.
	* @stable ICU 2.0		* @stable ICU 2.0
	*/		*/
	void parseObject(const UnicodeString& source,		void parseObject(const UnicodeString& source,
	Formattable& result,		Formattable& result,
	UErrorCode& status) const;		UErrorCode& status) const;
	/**
	* Returns a unique class ID POLYMORPHICALLY. Pure virtual method.
	* This method is to implement a simple version of RTTI, since not all
	* C++ compilers support genuine RTTI. Polymorphic operator==() and
	* clone() methods call this method.
	* Concrete subclasses of Format must implement getDynamicClassID()
	*
	* @return The class ID for this object. All objects of a
	* given class have the same class ID. Objects of
	* other classes have different class IDs.
	* @stable ICU 2.0
	*/
	virtual UClassID getDynamicClassID() const = 0;
	/** Get the locale for this format object. You can choose between valid and actual locale.		/** Get the locale for this format object. You can choose between valid and actual locale.
	* @param type type of the locale we're looking for (valid or actual)		* @param type type of the locale we're looking for (valid or actual)
	* @param status error code for the operation		* @param status error code for the operation
	* @return the locale		* @return the locale
	* @stable ICU 2.8		* @stable ICU 2.8
	*/		*/
	Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;		Locale getLocale(ULocDataLocaleType type, UErrorCode& status) const;
	/** Get the locale for this format object. You can choose between valid and actual locale.		/** Get the locale for this format object. You can choose between valid and actual locale.
	* @param type type of the locale we're looking for (valid or actual)		* @param type type of the locale we're looking for (valid or actual)
	* @param status error code for the operation		* @param status error code for the operation
	* @return the locale		* @return the locale
	* @internal		* @internal
	*/		*/
	const char* getLocaleID(ULocDataLocaleType type, UErrorCode &status) co nst;		const char* getLocaleID(ULocDataLocaleType type, UErrorCode &status) co nst;
			/**
			* Controls lenient parse behavior. At the Format class level, lenient
			parse
			* is on by default. Format subclasses may have different default behav
			ior
			* for lenient parse.
			*
			* @see #isLenient
			* @param lenient Sets lenient parse mode on (if TRUE) or off (if FALSE
			).
			* @draft ICU 4.6
			*/
			virtual void setLenient(UBool lenient);
			/**
			* Returns the status of lenient parse mode. At the Format class level,
			* lenient parse is on by default. Format subclasses may have different
			* default behavior for lenient parse.
			*
			* @see #setLenient
			* @return Lenient parse mode status: TRUE if on, FALSE if off.
			* @stable ICU 2.0
			*/
			virtual UBool isLenient(void) const;
	protected:		protected:
	/** @stable ICU 2.8 */		/** @stable ICU 2.8 */
	void setLocaleIDs(const char* valid, const char* actual);		void setLocaleIDs(const char* valid, const char* actual);
	protected:		protected:
	/**		/**
	* Default constructor for subclass use only. Does nothing.		* Default constructor for subclass use only. Does nothing.
	* @stable ICU 2.0		* @stable ICU 2.0
	*/		*/
	Format();		Format();
	skipping to change at line 308		skipping to change at line 321
	* @param parseError The UParseError object to fill in		* @param parseError The UParseError object to fill in
	* @stable ICU 2.4		* @stable ICU 2.4
	*/		*/
	static void syntaxError(const UnicodeString& pattern,		static void syntaxError(const UnicodeString& pattern,
	int32_t pos,		int32_t pos,
	UParseError& parseError);		UParseError& parseError);
	private:		private:
	char actualLocale[ULOC_FULLNAME_CAPACITY];		char actualLocale[ULOC_FULLNAME_CAPACITY];
	char validLocale[ULOC_FULLNAME_CAPACITY];		char validLocale[ULOC_FULLNAME_CAPACITY];
			UBool fLenient;
	};		};
	U_NAMESPACE_END		U_NAMESPACE_END
	#endif /* #if !UCONFIG_NO_FORMATTING */		#endif /* #if !UCONFIG_NO_FORMATTING */
	#endif // _FORMAT		#endif // _FORMAT
	//eof		//eof
End of changes. 4 change blocks.
	14 lines changed or deleted		31 lines changed or added

	fpositer.h		fpositer.h
	skipping to change at line 99		skipping to change at line 99
	*/		*/
	UBool operator!=(const FieldPositionIterator& rhs) const { return !oper ator==(rhs); }		UBool operator!=(const FieldPositionIterator& rhs) const { return !oper ator==(rhs); }
	/**		/**
	* If the current position is valid, updates the FieldPosition values, advances the iterator,		* If the current position is valid, updates the FieldPosition values, advances the iterator,
	* and returns TRUE, otherwise returns FALSE.		* and returns TRUE, otherwise returns FALSE.
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	UBool next(FieldPosition& fp);		UBool next(FieldPosition& fp);
	/**
	* ICU "poor man's RTTI", returns a UClassID for this class.
	* @draft ICU 4.4
	*/
	static UClassID U_EXPORT2 getStaticClassID();
	/**
	* ICU "poor man's RTTI", returns a UClassID for the actual class.
	* @draft ICU 4.4
	*/
	virtual UClassID getDynamicClassID() const;
	private:		private:
	friend class FieldPositionIteratorHandler;		friend class FieldPositionIteratorHandler;
	/**		/**
	* Sets the data used by the iterator, and resets the position.		* Sets the data used by the iterator, and resets the position.
	* Returns U_ILLEGAL_ARGUMENT_ERROR in status if the data is not valid		* Returns U_ILLEGAL_ARGUMENT_ERROR in status if the data is not valid
	* (length is not a multiple of 3, or start >= limit for any run).		* (length is not a multiple of 3, or start >= limit for any run).
	*/		*/
	void setData(UVector32 *adopt, UErrorCode& status);		void setData(UVector32 *adopt, UErrorCode& status);
	UVector32 *data;		UVector32 *data;
	int32_t pos;		int32_t pos;
			// No ICU "poor man's RTTI" for this class nor its subclasses.
			virtual UClassID getDynamicClassID() const;
	};		};
	U_NAMESPACE_END		U_NAMESPACE_END
	#endif /* #if !UCONFIG_NO_FORMATTING */		#endif /* #if !UCONFIG_NO_FORMATTING */
	#endif // FPOSITER_H		#endif // FPOSITER_H
End of changes. 2 change blocks.
	12 lines changed or deleted		3 lines changed or added

	locdspnm.h		locdspnm.h
	skipping to change at line 172		skipping to change at line 172
	* Returns the display name of the provided value (used with the provid ed key).		* Returns the display name of the provided value (used with the provid ed key).
	* @param key the locale key name		* @param key the locale key name
	* @param value the locale key's value		* @param value the locale key's value
	* @param result receives the value's display name		* @param result receives the value's display name
	* @return the display name of the provided value		* @return the display name of the provided value
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	virtual UnicodeString& keyValueDisplayName(const char* key, const char* value,		virtual UnicodeString& keyValueDisplayName(const char* key, const char* value,
	UnicodeString& result) const = 0;		UnicodeString& result) const = 0;
	/**		private:
	* ICU "poor man's RTTI", returns a UClassID for this class.		// No ICU "poor man's RTTI" for this class nor its subclasses.
	* @returns a UClassID for this class.		virtual UClassID getDynamicClassID() const;
	* @internal ICU 4.4 // TODO @draft ICU 4.6
	*/
	static UClassID U_EXPORT2 getStaticClassID();
	};		};
	inline LocaleDisplayNames::~LocaleDisplayNames() {		inline LocaleDisplayNames::~LocaleDisplayNames() {
	}		}
	inline LocaleDisplayNames* LocaleDisplayNames::createInstance(const Locale& locale) {		inline LocaleDisplayNames* LocaleDisplayNames::createInstance(const Locale& locale) {
	return LocaleDisplayNames::createInstance(locale, ULDN_STANDARD_NAMES);		return LocaleDisplayNames::createInstance(locale, ULDN_STANDARD_NAMES);
	}		}
	U_NAMESPACE_END		U_NAMESPACE_END
End of changes. 1 change blocks.
	6 lines changed or deleted		3 lines changed or added

	normalizer2.h		normalizer2.h
	skipping to change at line 40		skipping to change at line 40
	#include "unicode/unistr.h"		#include "unicode/unistr.h"
	#include "unicode/unorm2.h"		#include "unicode/unorm2.h"
	U_NAMESPACE_BEGIN		U_NAMESPACE_BEGIN
	/**		/**
	* Unicode normalization functionality for standard Unicode normalization o r		* Unicode normalization functionality for standard Unicode normalization o r
	* for using custom mapping tables.		* for using custom mapping tables.
	* All instances of this class are unmodifiable/immutable.		* All instances of this class are unmodifiable/immutable.
	* Instances returned by getInstance() are singletons that must not be dele ted by the caller.		* Instances returned by getInstance() are singletons that must not be dele ted by the caller.
			* The Normalizer2 class is not intended for public subclassing.
	*		*
	* The primary functions are to produce a normalized string and to detect w hether		* The primary functions are to produce a normalized string and to detect w hether
	* a string is already normalized.		* a string is already normalized.
	* The most commonly used normalization forms are those defined in		* The most commonly used normalization forms are those defined in
	* http://www.unicode.org/unicode/reports/tr15/		* http://www.unicode.org/unicode/reports/tr15/
	* However, this API supports additional normalization forms for specialize d purposes.		* However, this API supports additional normalization forms for specialize d purposes.
	* For example, NFKC_Casefold is provided via getInstance("nfkc_cf", COMPOS E)		* For example, NFKC_Casefold is provided via getInstance("nfkc_cf", COMPOS E)
	* and can be used in implementations of UTS #46.		* and can be used in implementations of UTS #46.
	*		*
	* Not only are the standard compose and decompose modes supplied,		* Not only are the standard compose and decompose modes supplied,
	skipping to change at line 177		skipping to change at line 178
	* function chaining. (See User Guide for details.)		* function chaining. (See User Guide for details.)
	* @return first		* @return first
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	virtual UnicodeString &		virtual UnicodeString &
	append(UnicodeString &first,		append(UnicodeString &first,
	const UnicodeString &second,		const UnicodeString &second,
	UErrorCode &errorCode) const = 0;		UErrorCode &errorCode) const = 0;
	/**		/**
			* Gets the decomposition mapping of c. Equivalent to normalize(Unicode
			String(c))
			* on a UNORM2_DECOMPOSE Normalizer2 instance, but much faster.
			* This function is independent of the mode of the Normalizer2.
			* @param c code point
			* @param decomposition String object which will be set to c's
			* decomposition mapping, if there is one.
			* @return TRUE if c has a decomposition, otherwise FALSE
			* @draft ICU 4.6
			*/
			virtual UBool
			getDecomposition(UChar32 c, UnicodeString &decomposition) const = 0;
			/**
	* Tests if the string is normalized.		* Tests if the string is normalized.
	* Internally, in cases where the quickCheck() method would return "may be"		* Internally, in cases where the quickCheck() method would return "may be"
	* (which is only possible for the two COMPOSE modes) this method		* (which is only possible for the two COMPOSE modes) this method
	* resolves to "yes" or "no" to provide a definitive result,		* resolves to "yes" or "no" to provide a definitive result,
	* at the cost of doing more work in those cases.		* at the cost of doing more work in those cases.
	* @param s input string		* @param s input string
	* @param errorCode Standard ICU error code. Its input value must		* @param errorCode Standard ICU error code. Its input value must
	* pass the U_SUCCESS() test, or else the function ret urns		* pass the U_SUCCESS() test, or else the function ret urns
	* immediately. Check for U_FAILURE() on output or use with		* immediately. Check for U_FAILURE() on output or use with
	* function chaining. (See User Guide for details.)		* function chaining. (See User Guide for details.)
	skipping to change at line 282		skipping to change at line 296
	* by processing portions before this character and after this		* by processing portions before this character and after this
	* character independently.		* character independently.
	* This is used for iterative normalization. See the class documentatio n for details.		* This is used for iterative normalization. See the class documentatio n for details.
	* Note that this operation may be significantly slower than hasBoundar yBefore().		* Note that this operation may be significantly slower than hasBoundar yBefore().
	* @param c character to test		* @param c character to test
	* @return TRUE if c is normalization-inert		* @return TRUE if c is normalization-inert
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	virtual UBool isInert(UChar32 c) const = 0;		virtual UBool isInert(UChar32 c) const = 0;
	/**		private:
	* ICU "poor man's RTTI", returns a UClassID for this class.		// No ICU "poor man's RTTI" for this class nor its subclasses.
	* @returns a UClassID for this class.		virtual UClassID getDynamicClassID() const;
	* @draft ICU 4.4
	*/
	static UClassID U_EXPORT2 getStaticClassID();
	/**
	* ICU "poor man's RTTI", returns a UClassID for the actual class.
	* @return a UClassID for the actual class.
	* @draft ICU 4.4
	*/
	virtual UClassID getDynamicClassID() const = 0;
	};		};
	/**		/**
	* Normalization filtered by a UnicodeSet.		* Normalization filtered by a UnicodeSet.
	* Normalizes portions of the text contained in the filter set and leaves		* Normalizes portions of the text contained in the filter set and leaves
	* portions not contained in the filter set unchanged.		* portions not contained in the filter set unchanged.
	* Filtering is done via UnicodeSet::span(..., USET_SPAN_SIMPLE).		* Filtering is done via UnicodeSet::span(..., USET_SPAN_SIMPLE).
	* Not-in-the-filter text is treated as "is normalized" and "quick check ye s".		* Not-in-the-filter text is treated as "is normalized" and "quick check ye s".
	* This class implements all of (and only) the Normalizer2 API.		* This class implements all of (and only) the Normalizer2 API.
	* An instance of this class is unmodifiable/immutable but is constructed a nd		* An instance of this class is unmodifiable/immutable but is constructed a nd
	skipping to change at line 378		skipping to change at line 382
	* function chaining. (See User Guide for details.)		* function chaining. (See User Guide for details.)
	* @return first		* @return first
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	virtual UnicodeString &		virtual UnicodeString &
	append(UnicodeString &first,		append(UnicodeString &first,
	const UnicodeString &second,		const UnicodeString &second,
	UErrorCode &errorCode) const;		UErrorCode &errorCode) const;
	/**		/**
			* Gets the decomposition mapping of c. Equivalent to normalize(Unicode
			String(c))
			* on a UNORM2_DECOMPOSE Normalizer2 instance, but much faster.
			* This function is independent of the mode of the Normalizer2.
			* @param c code point
			* @param decomposition String object which will be set to c's
			* decomposition mapping, if there is one.
			* @return TRUE if c has a decomposition, otherwise FALSE
			* @draft ICU 4.6
			*/
			virtual UBool
			getDecomposition(UChar32 c, UnicodeString &decomposition) const;
			/**
	* Tests if the string is normalized.		* Tests if the string is normalized.
	* For details see the Normalizer2 base class documentation.		* For details see the Normalizer2 base class documentation.
	* @param s input string		* @param s input string
	* @param errorCode Standard ICU error code. Its input value must		* @param errorCode Standard ICU error code. Its input value must
	* pass the U_SUCCESS() test, or else the function ret urns		* pass the U_SUCCESS() test, or else the function ret urns
	* immediately. Check for U_FAILURE() on output or use with		* immediately. Check for U_FAILURE() on output or use with
	* function chaining. (See User Guide for details.)		* function chaining. (See User Guide for details.)
	* @return TRUE if s is normalized		* @return TRUE if s is normalized
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	skipping to change at line 445		skipping to change at line 462
	virtual UBool hasBoundaryAfter(UChar32 c) const;		virtual UBool hasBoundaryAfter(UChar32 c) const;
	/**		/**
	* Tests if the character is normalization-inert.		* Tests if the character is normalization-inert.
	* For details see the Normalizer2 base class documentation.		* For details see the Normalizer2 base class documentation.
	* @param c character to test		* @param c character to test
	* @return TRUE if c is normalization-inert		* @return TRUE if c is normalization-inert
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	virtual UBool isInert(UChar32 c) const;		virtual UBool isInert(UChar32 c) const;
	/**
	* ICU "poor man's RTTI", returns a UClassID for this class.
	* @returns a UClassID for this class.
	* @draft ICU 4.4
	*/
	static UClassID U_EXPORT2 getStaticClassID();
	/**
	* ICU "poor man's RTTI", returns a UClassID for the actual class.
	* @return a UClassID for the actual class.
	* @draft ICU 4.4
	*/
	virtual UClassID getDynamicClassID() const;
	private:		private:
	UnicodeString &		UnicodeString &
	normalize(const UnicodeString &src,		normalize(const UnicodeString &src,
	UnicodeString &dest,		UnicodeString &dest,
	USetSpanCondition spanCondition,		USetSpanCondition spanCondition,
	UErrorCode &errorCode) const;		UErrorCode &errorCode) const;
	UnicodeString &		UnicodeString &
	normalizeSecondAndAppend(UnicodeString &first,		normalizeSecondAndAppend(UnicodeString &first,
	const UnicodeString &second,		const UnicodeString &second,
End of changes. 5 change blocks.
	27 lines changed or deleted		32 lines changed or added

	numfmt.h		numfmt.h
	skipping to change at line 104		skipping to change at line 104
	* \endcode		* \endcode
	* </pre>		* </pre>
	* You can use a NumberFormat to parse also.		* You can use a NumberFormat to parse also.
	* <pre>		* <pre>
	* \code		* \code
	* UErrorCode success;		* UErrorCode success;
	* Formattable result(-999); // initialized with error code		* Formattable result(-999); // initialized with error code
	* nf->parse(myString, result, success);		* nf->parse(myString, result, success);
	* \endcode		* \endcode
	* </pre>		* </pre>
			* Note that while lenient parsing is on by default for the Format base cla
			ss,
			* it is off by default for NumberFormat and its subclasses.
			* <P>
	* Use createInstance to get the normal number format for that country.		* Use createInstance to get the normal number format for that country.
	* There are other static factory methods available. Use getCurrency		* There are other static factory methods available. Use getCurrency
	* to get the currency number format for that country. Use getPercent		* to get the currency number format for that country. Use getPercent
	* to get a format for displaying percentages. With this format, a		* to get a format for displaying percentages. With this format, a
	* fraction from 0.53 is displayed as 53%.		* fraction from 0.53 is displayed as 53%.
	* <P>		* <P>
	* Starting from ICU 4.2, you can use createInstance() by passing in a 'sty le'		* Starting from ICU 4.2, you can use createInstance() by passing in a 'sty le'
	* as parameter to get the correct instance.		* as parameter to get the correct instance.
	* For example,		* For example,
	* use createInstance(...kNumberStyle...) to get the normal number format,		* use createInstance(...kNumberStyle...) to get the normal number format,
End of changes. 1 change blocks.
	0 lines changed or deleted		4 lines changed or added

	numsys.h		numsys.h
	skipping to change at line 19		skipping to change at line 19
	*		*
	* Modification History:*		* Modification History:*
	* Date Name Description		* Date Name Description
	*		*
	*************************************************************************** *****		*************************************************************************** *****
	*/		*/
	#ifndef NUMSYS		#ifndef NUMSYS
	#define NUMSYS		#define NUMSYS
			/**
			* \def NUMSYS_NAME_CAPACITY
			* Size of a numbering system name.
			* @internal
			*/
			#define NUMSYS_NAME_CAPACITY 8
	#include "unicode/utypes.h"		#include "unicode/utypes.h"
	/**		/**
	* \file		* \file
	* \brief C++ API: NumberingSystem object		* \brief C++ API: NumberingSystem object
	*/		*/
	#if !UCONFIG_NO_FORMATTING		#if !UCONFIG_NO_FORMATTING
	#include "unicode/format.h"		#include "unicode/format.h"
	skipping to change at line 117		skipping to change at line 124
	*/		*/
	static NumberingSystem* U_EXPORT2 createInstanceByName(const char* name , UErrorCode& status);		static NumberingSystem* U_EXPORT2 createInstanceByName(const char* name , UErrorCode& status);
	/**		/**
	* Returns the radix of this numbering system.		* Returns the radix of this numbering system.
	* @stable ICU 4.2		* @stable ICU 4.2
	*/		*/
	int32_t getRadix();		int32_t getRadix();
	/**		/**
			* Returns the name of this numbering system if it was created using on
			e of the predefined names
			* known to ICU. Otherwise, returns NULL.
			* @draft ICU 4.6
			*/
			const char * getName();
			/**
	* Returns the description string of this numbering system, which is ei ther		* Returns the description string of this numbering system, which is ei ther
	* the string of digits in the case of simple systems, or the ruleset n ame		* the string of digits in the case of simple systems, or the ruleset n ame
	* in the case of algorithmic systems.		* in the case of algorithmic systems.
	* @stable ICU 4.2		* @stable ICU 4.2
	*/		*/
	virtual UnicodeString getDescription();		virtual UnicodeString getDescription();
	/**		/**
	* Returns TRUE if the given numbering system is algorithmic		* Returns TRUE if the given numbering system is algorithmic
	*		*
	skipping to change at line 152		skipping to change at line 166
	* ICU "poor man's RTTI", returns a UClassID for the actual class.		* ICU "poor man's RTTI", returns a UClassID for the actual class.
	*		*
	* @stable ICU 4.2		* @stable ICU 4.2
	*/		*/
	virtual UClassID getDynamicClassID() const;		virtual UClassID getDynamicClassID() const;
	private:		private:
	UnicodeString desc;		UnicodeString desc;
	int32_t radix;		int32_t radix;
	UBool algorithmic;		UBool algorithmic;
			char name[NUMSYS_NAME_CAPACITY+1];
	void setRadix(int32_t radix);		void setRadix(int32_t radix);
	void setAlgorithmic(UBool algorithmic);		void setAlgorithmic(UBool algorithmic);
	void setDesc(UnicodeString desc);		void setDesc(UnicodeString desc);
			void setName(const char* name);
	static UBool isValidDigitString(const UnicodeString &str);		static UBool isValidDigitString(const UnicodeString &str);
	UBool hasContiguousDecimalDigits() const;		UBool hasContiguousDecimalDigits() const;
	};		};
	U_NAMESPACE_END		U_NAMESPACE_END
	#endif /* #if !UCONFIG_NO_FORMATTING */		#endif /* #if !UCONFIG_NO_FORMATTING */
	#endif // _NUMSYS		#endif // _NUMSYS
End of changes. 4 change blocks.
	0 lines changed or deleted		18 lines changed or added

	platform.h		platform.h
	skipping to change at line 394		skipping to change at line 394
	# define U_LIB_SUFFIX_C_NAME_STRING ""		# define U_LIB_SUFFIX_C_NAME_STRING ""
	/**		/**
	* 1 if a custom library suffix is set		* 1 if a custom library suffix is set
	* @internal		* @internal
	*/		*/
	# define U_HAVE_LIB_SUFFIX 0		# define U_HAVE_LIB_SUFFIX 0
	#if U_HAVE_LIB_SUFFIX		#if U_HAVE_LIB_SUFFIX
	# ifndef U_ICU_ENTRY_POINT_RENAME		# ifndef U_ICU_ENTRY_POINT_RENAME
	/* Renaming pattern: u_strcpy_41_suffix */		/* Renaming pattern: u_strcpy_41_suffix */
	# define U_ICU_ENTRY_POINT_RENAME(x) x ## _ ## 44 ##		# define U_ICU_ENTRY_POINT_RENAME(x) x ## _ ## 45 ##
	# define U_DEF_ICUDATA_ENTRY_POINT(major, minor) icudt####major##minor##_d at		# define U_DEF_ICUDATA_ENTRY_POINT(major, minor) icudt####major##minor##_d at
	# endif		# endif
	#endif		#endif
	#endif		#endif
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	rbnf.h		rbnf.h
	skipping to change at line 928		skipping to change at line 928
	*/		*/
	virtual void setLenient(UBool enabled);		virtual void setLenient(UBool enabled);
	/**		/**
	* Returns true if lenient-parse mode is turned on. Lenient parsing is o ff		* Returns true if lenient-parse mode is turned on. Lenient parsing is o ff
	* by default.		* by default.
	* @return true if lenient-parse mode is turned on.		* @return true if lenient-parse mode is turned on.
	* @see #setLenient		* @see #setLenient
	* @stable ICU 2.0		* @stable ICU 2.0
	*/		*/
	virtual inline UBool isLenient(void) const;		virtual UBool isLenient(void) const;
	#endif		#endif
	/**		/**
	* Override the default rule set to use. If ruleSetName is null, reset		* Override the default rule set to use. If ruleSetName is null, reset
	* to the initial default rule set. If the rule set is not a public rule set name,		* to the initial default rule set. If the rule set is not a public rule set name,
	* U_ILLEGAL_ARGUMENT_ERROR is returned in status.		* U_ILLEGAL_ARGUMENT_ERROR is returned in status.
	* @param ruleSetName the name of the rule set, or null to reset the init ial default.		* @param ruleSetName the name of the rule set, or null to reset the init ial default.
	* @param status set to failure code when a problem occurs.		* @param status set to failure code when a problem occurs.
	* @stable ICU 2.6		* @stable ICU 2.6
	skipping to change at line 995		skipping to change at line 995
	inline NFRuleSet * getDefaultRuleSet() const;		inline NFRuleSet * getDefaultRuleSet() const;
	Collator * getCollator() const;		Collator * getCollator() const;
	DecimalFormatSymbols * getDecimalFormatSymbols() const;		DecimalFormatSymbols * getDecimalFormatSymbols() const;
	private:		private:
	NFRuleSet **ruleSets;		NFRuleSet **ruleSets;
	NFRuleSet *defaultRuleSet;		NFRuleSet *defaultRuleSet;
	Locale locale;		Locale locale;
	Collator* collator;		Collator* collator;
	DecimalFormatSymbols* decimalFormatSymbols;		DecimalFormatSymbols* decimalFormatSymbols;
	UBool lenient;
	UnicodeString* lenientParseRules;		UnicodeString* lenientParseRules;
	LocalizationInfo* localizations;		LocalizationInfo* localizations;
	// Temporary workaround - when noParse is true, do noting in parse.		// Temporary workaround - when noParse is true, do noting in parse.
	// TODO: We need a real fix - see #6895/#6896		// TODO: We need a real fix - see #6895/#6896
	UBool noParse;		UBool noParse;
	};		};
	// ---------------		// ---------------
	skipping to change at line 1037		skipping to change at line 1036
	FieldPosition pos(0);		FieldPosition pos(0);
	return format(number, output, pos);		return format(number, output, pos);
	}		}
	inline void		inline void
	RuleBasedNumberFormat::parse(const UnicodeString& text, Formattable& result , UErrorCode& status) const		RuleBasedNumberFormat::parse(const UnicodeString& text, Formattable& result , UErrorCode& status) const
	{		{
	NumberFormat::parse(text, result, status);		NumberFormat::parse(text, result, status);
	}		}
	#if !UCONFIG_NO_COLLATION
	inline UBool
	RuleBasedNumberFormat::isLenient(void) const {
	return lenient;
	}
	#endif
	inline NFRuleSet*		inline NFRuleSet*
	RuleBasedNumberFormat::getDefaultRuleSet() const {		RuleBasedNumberFormat::getDefaultRuleSet() const {
	return defaultRuleSet;		return defaultRuleSet;
	}		}
	U_NAMESPACE_END		U_NAMESPACE_END
	/* U_HAVE_RBNF */		/* U_HAVE_RBNF */
	#endif		#endif
End of changes. 3 change blocks.
	11 lines changed or deleted		1 lines changed or added

	regex.h		regex.h
	skipping to change at line 1487		skipping to change at line 1487
	* callback function.		* callback function.
	* @param context Out parameter, receives the user context poin ter that		* @param context Out parameter, receives the user context poin ter that
	* was set when uregex_setMatchCallback() was ca lled.		* was set when uregex_setMatchCallback() was ca lled.
	* @param status A reference to a UErrorCode to receive any er rors.		* @param status A reference to a UErrorCode to receive any er rors.
	* @stable ICU 4.0		* @stable ICU 4.0
	*/		*/
	virtual void getMatchCallback(URegexMatchCallback *&callback,		virtual void getMatchCallback(URegexMatchCallback *&callback,
	const void *&context,		const void *&context,
	UErrorCode &status);		UErrorCode &status);
			/**
			* Set a progress callback function for use with find operations on this
			Matcher.
			* During find operations, the callback will be invoked after each retur
			n from a
			* match attempt, giving the application the opportunity to terminate a
			long-running
			* find operation.
			*
			* @param callback A pointer to the user-supplied callback funct
			ion.
			* @param context User context pointer. The value supplied at
			the
			* time the callback function is set will be sav
			ed
			* and passed to the callback each time that it
			is called.
			* @param status A reference to a UErrorCode to receive any er
			rors.
			* @draft ICU 4.6
			*/
			virtual void setFindProgressCallback(URegexFindProgressCallback *c
			allback,
			const void
			*context,
			UErrorCode
			&status);
			/**
			* Get the find progress callback function for this URegularExpression.
			*
			* @param callback Out paramater, receives a pointer to the user
			-supplied
			* callback function.
			* @param context Out parameter, receives the user context poin
			ter that
			* was set when uregex_setFindProgressCallback()
			was called.
			* @param status A reference to a UErrorCode to receive any er
			rors.
			* @draft ICU 4.6
			*/
			virtual void getFindProgressCallback(URegexFindProgressCallback *&
			callback,
			const void
			*&context,
			UErrorCode
			&status);
	/**		/**
	* setTrace Debug function, enable/disable tracing of the matching engine.		* setTrace Debug function, enable/disable tracing of the matching engine.
	* For internal ICU development use only. DO NO USE!!!!		* For internal ICU development use only. DO NO USE!!!!
	* @internal		* @internal
	*/		*/
	void setTrace(UBool state);		void setTrace(UBool state);
	/**		/**
	* ICU "poor man's RTTI", returns a UClassID for this class.		* ICU "poor man's RTTI", returns a UClassID for this class.
	*		*
	skipping to change at line 1536		skipping to change at line 1567
	// MatchAt This is the internal interface to the match engine itself .		// MatchAt This is the internal interface to the match engine itself .
	// Match status comes back in matcher member variables.		// Match status comes back in matcher member variables.
	//		//
	void MatchAt(int64_t startIdx, UBool toEnd, UErrorCode &status);		void MatchAt(int64_t startIdx, UBool toEnd, UErrorCode &status);
	inline void backTrack(int64_t &inputIdx, int32_t &patIdx);		inline void backTrack(int64_t &inputIdx, int32_t &patIdx);
	UBool isWordBoundary(int64_t pos); // perform Pe rl-like \b test		UBool isWordBoundary(int64_t pos); // perform Pe rl-like \b test
	UBool isUWordBoundary(int64_t pos); // perform RB BI based \b test		UBool isUWordBoundary(int64_t pos); // perform RB BI based \b test
	REStackFrame *resetStack();		REStackFrame *resetStack();
	inline REStackFrame *StateSave(REStackFrame *fp, int64_t savePatIdx, UE rrorCode &status);		inline REStackFrame *StateSave(REStackFrame *fp, int64_t savePatIdx, UE rrorCode &status);
	void IncrementTime(UErrorCode &status);		void IncrementTime(UErrorCode &status);
			UBool ReportFindProgress(int64_t matchIndex, UErrorCode &status);
	int64_t appendGroup(int32_t groupNum, UText *dest, UErrorC ode &status) const;		int64_t appendGroup(int32_t groupNum, UText *dest, UErrorC ode &status) const;
	UBool findUsingChunk();		UBool findUsingChunk();
	void MatchChunkAt(int32_t startIdx, UBool toEnd, UError Code &status);		void MatchChunkAt(int32_t startIdx, UBool toEnd, UError Code &status);
	UBool isChunkWordBoundary(int32_t pos);		UBool isChunkWordBoundary(int32_t pos);
	const RegexPattern *fPattern;		const RegexPattern *fPattern;
	RegexPattern *fPatternOwned; // Non-NULL if this matcher owns the pattern, and		RegexPattern *fPatternOwned; // Non-NULL if this matcher owns the pattern, and
	// should delete it when throu gh.		// should delete it when throu gh.
	skipping to change at line 1611		skipping to change at line 1643
	// code as possible out of the inline		// code as possible out of the inline
	// StateSave function.		// StateSave function.
	int32_t fStackLimit; // Maximum memory size to use fo r the backtrack		int32_t fStackLimit; // Maximum memory size to use fo r the backtrack
	// stack, in bytes. Zero for unlimited.		// stack, in bytes. Zero for unlimited.
	URegexMatchCallback *fCallbackFn; // Pointer to match progress ca llback funct.		URegexMatchCallback *fCallbackFn; // Pointer to match progress ca llback funct.
	// NULL if there is no callbac k.		// NULL if there is no callbac k.
	const void *fCallbackContext; // User Context ptr for callback function.		const void *fCallbackContext; // User Context ptr for callback function.
			URegexFindProgressCallback *fFindProgressCallbackFn; // Pointer to ma
			tch progress callback funct.
			// NULL if the
			re is no callback.
			const void *fFindProgressCallbackContext; // User Context
			ptr for callback function.
	UBool fInputUniStrMaybeMutable; // Set when fInputText w raps a UnicodeString that may be mutable - compatibility.		UBool fInputUniStrMaybeMutable; // Set when fInputText w raps a UnicodeString that may be mutable - compatibility.
	UBool fTraceDebug; // Set true for debug tracing of match engine.		UBool fTraceDebug; // Set true for debug tracing of match engine.
	UErrorCode fDeferredStatus; // Save error state that cannot be immediately		UErrorCode fDeferredStatus; // Save error state that cannot be immediately
	// reported, or that permanent ly disables this matcher.		// reported, or that permanent ly disables this matcher.
	RuleBasedBreakIterator *fWordBreakItr;		RuleBasedBreakIterator *fWordBreakItr;
	};		};
End of changes. 3 change blocks.
	0 lines changed or deleted		57 lines changed or added

	ucol.h		ucol.h
	skipping to change at line 729		skipping to change at line 729
	U_STABLE int32_t U_EXPORT2		U_STABLE int32_t U_EXPORT2
	ucol_normalizeShortDefinitionString(const char *source,		ucol_normalizeShortDefinitionString(const char *source,
	char *destination,		char *destination,
	int32_t capacity,		int32_t capacity,
	UParseError *parseError,		UParseError *parseError,
	UErrorCode *status);		UErrorCode *status);
	/**		/**
	* Get a sort key for a string from a UCollator.		* Get a sort key for a string from a UCollator.
	* Sort keys may be compared using <TT>strcmp</TT>.		* Sort keys may be compared using <TT>strcmp</TT>.
			*
			* Like ICU functions that write to an output buffer, the buffer contents
			* is undefined if the buffer capacity (resultLength parameter) is too smal
			l.
			* Unlike ICU functions that write a string to an output buffer,
			* the terminating zero byte is counted in the sort key length.
	* @param coll The UCollator containing the collation rules.		* @param coll The UCollator containing the collation rules.
	* @param source The string to transform.		* @param source The string to transform.
	* @param sourceLength The length of source, or -1 if null-terminated.		* @param sourceLength The length of source, or -1 if null-terminated.
	* @param result A pointer to a buffer to receive the attribute.		* @param result A pointer to a buffer to receive the attribute.
	* @param resultLength The maximum size of result.		* @param resultLength The maximum size of result.
	* @return The size needed to fully store the sort key.		* @return The size needed to fully store the sort key.
	* If there was an internal error generating the sort key,		* If there was an internal error generating the sort key,
	* a zero value is returned.		* a zero value is returned.
	* @see ucol_keyHashCode		* @see ucol_keyHashCode
	* @stable ICU 2.0		* @stable ICU 2.0
End of changes. 1 change blocks.
	0 lines changed or deleted		6 lines changed or added

	udeprctd.h		udeprctd.h
	skipping to change at line 37		skipping to change at line 37
	# define ucol_getContractions ucol_getContractions_DEPRECATED_API_DO _NOT_USE		# define ucol_getContractions ucol_getContractions_DEPRECATED_API_DO _NOT_USE
	# define ucol_getLocale ucol_getLocale_DEPRECATED_API_DO_NOT_USE		# define ucol_getLocale ucol_getLocale_DEPRECATED_API_DO_NOT_USE
	# define ures_countArrayItems ures_countArrayItems_DEPRECATED_API_DO _NOT_USE		# define ures_countArrayItems ures_countArrayItems_DEPRECATED_API_DO _NOT_USE
	# define ures_getLocale ures_getLocale_DEPRECATED_API_DO_NOT_USE		# define ures_getLocale ures_getLocale_DEPRECATED_API_DO_NOT_USE
	# define ures_getVersionNumber ures_getVersionNumber_DEPRECATED_API_ DO_NOT_USE		# define ures_getVersionNumber ures_getVersionNumber_DEPRECATED_API_ DO_NOT_USE
	# define utrans_getAvailableID utrans_getAvailableID_DEPRECATED_API_ DO_NOT_USE		# define utrans_getAvailableID utrans_getAvailableID_DEPRECATED_API_ DO_NOT_USE
	# define utrans_getID utrans_getID_DEPRECATED_API_DO_NOT_USE		# define utrans_getID utrans_getID_DEPRECATED_API_DO_NOT_USE
	# define utrans_open utrans_open_DEPRECATED_API_DO_NOT_USE		# define utrans_open utrans_open_DEPRECATED_API_DO_NOT_USE
	# define utrans_unregister utrans_unregister_DEPRECATED_API_DO_NOT_U SE		# define utrans_unregister utrans_unregister_DEPRECATED_API_DO_NOT_U SE
	# else		# else
	# define ucol_getContractions_4_4 ucol_getContractions_DEPRECATED_AP		# define ucol_getContractions_4_5 ucol_getContractions_DEPRECATED_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define ucol_getLocale_4_4 ucol_getLocale_DEPRECATED_API_DO_NOT_USE		# define ucol_getLocale_4_5 ucol_getLocale_DEPRECATED_API_DO_NOT_USE
	# define ures_countArrayItems_4_4 ures_countArrayItems_DEPRECATED_AP		# define ures_countArrayItems_4_5 ures_countArrayItems_DEPRECATED_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define ures_getLocale_4_4 ures_getLocale_DEPRECATED_API_DO_NOT_USE		# define ures_getLocale_4_5 ures_getLocale_DEPRECATED_API_DO_NOT_USE
	# define ures_getVersionNumber_4_4 ures_getVersionNumber_DEPRECATED_		# define ures_getVersionNumber_4_5 ures_getVersionNumber_DEPRECATED_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define utrans_getAvailableID_4_4 utrans_getAvailableID_DEPRECATED_		# define utrans_getAvailableID_4_5 utrans_getAvailableID_DEPRECATED_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define utrans_getID_4_4 utrans_getID_DEPRECATED_API_DO_NOT_USE		# define utrans_getID_4_5 utrans_getID_DEPRECATED_API_DO_NOT_USE
	# define utrans_open_4_4 utrans_open_DEPRECATED_API_DO_NOT_USE		# define utrans_open_4_5 utrans_open_DEPRECATED_API_DO_NOT_USE
	# define utrans_unregister_4_4 utrans_unregister_DEPRECATED_API_DO_N		# define utrans_unregister_4_5 utrans_unregister_DEPRECATED_API_DO_N
	OT_USE		OT_USE
	# endif /* U_DISABLE_RENAMING */		# endif /* U_DISABLE_RENAMING */
	#endif /* U_HIDE_DEPRECATED_API */		#endif /* U_HIDE_DEPRECATED_API */
	#endif /* UDEPRCTD_H */		#endif /* UDEPRCTD_H */
End of changes. 1 change blocks.
	14 lines changed or deleted		14 lines changed or added

	udraft.h		udraft.h
	skipping to change at line 37		skipping to change at line 37
	# define bamuScriptCode bamuScriptCode_DRAFT_API_DO_NOT_USE		# define bamuScriptCode bamuScriptCode_DRAFT_API_DO_NOT_USE
	# define u_fadopt u_fadopt_DRAFT_API_DO_NOT_USE		# define u_fadopt u_fadopt_DRAFT_API_DO_NOT_USE
	# define u_strFromJavaModifiedUTF8WithSub u_strFromJavaModifiedUTF8W ithSub_DRAFT_API_DO_NOT_USE		# define u_strFromJavaModifiedUTF8WithSub u_strFromJavaModifiedUTF8W ithSub_DRAFT_API_DO_NOT_USE
	# define u_strToJavaModifiedUTF8 u_strToJavaModifiedUTF8_DRAFT_API_D O_NOT_USE		# define u_strToJavaModifiedUTF8 u_strToJavaModifiedUTF8_DRAFT_API_D O_NOT_USE
	# define ucal_getDayOfWeekType ucal_getDayOfWeekType_DRAFT_API_DO_NO T_USE		# define ucal_getDayOfWeekType ucal_getDayOfWeekType_DRAFT_API_DO_NO T_USE
	# define ucal_getWeekendTransition ucal_getWeekendTransition_DRAFT_A PI_DO_NOT_USE		# define ucal_getWeekendTransition ucal_getWeekendTransition_DRAFT_A PI_DO_NOT_USE
	# define ucal_isWeekend ucal_isWeekend_DRAFT_API_DO_NOT_USE		# define ucal_isWeekend ucal_isWeekend_DRAFT_API_DO_NOT_USE
	# define udat_toCalendarDateField udat_toCalendarDateField_DRAFT_API _DO_NOT_USE		# define udat_toCalendarDateField udat_toCalendarDateField_DRAFT_API _DO_NOT_USE
	# define udatpg_getBestPatternWithOptions udatpg_getBestPatternWithO ptions_DRAFT_API_DO_NOT_USE		# define udatpg_getBestPatternWithOptions udatpg_getBestPatternWithO ptions_DRAFT_API_DO_NOT_USE
	# define udatpg_replaceFieldTypesWithOptions udatpg_replaceFieldType sWithOptions_DRAFT_API_DO_NOT_USE		# define udatpg_replaceFieldTypesWithOptions udatpg_replaceFieldType sWithOptions_DRAFT_API_DO_NOT_USE
			# define uidna_close uidna_close_DRAFT_API_DO_NOT_USE
			# define uidna_labelToASCII uidna_labelToASCII_DRAFT_API_DO_NOT_USE
			# define uidna_labelToASCII_UTF8 uidna_labelToASCII_UTF8_DRAFT_API_D
			O_NOT_USE
			# define uidna_labelToUnicode uidna_labelToUnicode_DRAFT_API_DO_NOT_
			USE
			# define uidna_labelToUnicodeUTF8 uidna_labelToUnicodeUTF8_DRAFT_API
			_DO_NOT_USE
			# define uidna_nameToASCII uidna_nameToASCII_DRAFT_API_DO_NOT_USE
			# define uidna_nameToASCII_UTF8 uidna_nameToASCII_UTF8_DRAFT_API_DO_
			NOT_USE
			# define uidna_nameToUnicode uidna_nameToUnicode_DRAFT_API_DO_NOT_US
			E
			# define uidna_nameToUnicodeUTF8 uidna_nameToUnicodeUTF8_DRAFT_API_D
			O_NOT_USE
			# define uidna_openUTS46 uidna_openUTS46_DRAFT_API_DO_NOT_USE
	# define uldn_close uldn_close_DRAFT_API_DO_NOT_USE		# define uldn_close uldn_close_DRAFT_API_DO_NOT_USE
	# define uldn_getDialectHandling uldn_getDialectHandling_DRAFT_API_D O_NOT_USE		# define uldn_getDialectHandling uldn_getDialectHandling_DRAFT_API_D O_NOT_USE
	# define uldn_getLocale uldn_getLocale_DRAFT_API_DO_NOT_USE		# define uldn_getLocale uldn_getLocale_DRAFT_API_DO_NOT_USE
	# define uldn_keyDisplayName uldn_keyDisplayName_DRAFT_API_DO_NOT_US E		# define uldn_keyDisplayName uldn_keyDisplayName_DRAFT_API_DO_NOT_US E
	# define uldn_keyValueDisplayName uldn_keyValueDisplayName_DRAFT_API _DO_NOT_USE		# define uldn_keyValueDisplayName uldn_keyValueDisplayName_DRAFT_API _DO_NOT_USE
	# define uldn_languageDisplayName uldn_languageDisplayName_DRAFT_API _DO_NOT_USE		# define uldn_languageDisplayName uldn_languageDisplayName_DRAFT_API _DO_NOT_USE
	# define uldn_localeDisplayName uldn_localeDisplayName_DRAFT_API_DO_ NOT_USE		# define uldn_localeDisplayName uldn_localeDisplayName_DRAFT_API_DO_ NOT_USE
	# define uldn_open uldn_open_DRAFT_API_DO_NOT_USE		# define uldn_open uldn_open_DRAFT_API_DO_NOT_USE
	# define uldn_regionDisplayName uldn_regionDisplayName_DRAFT_API_DO_ NOT_USE		# define uldn_regionDisplayName uldn_regionDisplayName_DRAFT_API_DO_ NOT_USE
	# define uldn_scriptCodeDisplayName uldn_scriptCodeDisplayName_DRAFT _API_DO_NOT_USE		# define uldn_scriptCodeDisplayName uldn_scriptCodeDisplayName_DRAFT _API_DO_NOT_USE
	# define uldn_scriptDisplayName uldn_scriptDisplayName_DRAFT_API_DO_ NOT_USE		# define uldn_scriptDisplayName uldn_scriptDisplayName_DRAFT_API_DO_ NOT_USE
	# define uldn_variantDisplayName uldn_variantDisplayName_DRAFT_API_D O_NOT_USE		# define uldn_variantDisplayName uldn_variantDisplayName_DRAFT_API_D O_NOT_USE
	# define uloc_forLanguageTag uloc_forLanguageTag_DRAFT_API_DO_NOT_US E		# define uloc_forLanguageTag uloc_forLanguageTag_DRAFT_API_DO_NOT_US E
	# define uloc_toLanguageTag uloc_toLanguageTag_DRAFT_API_DO_NOT_USE		# define uloc_toLanguageTag uloc_toLanguageTag_DRAFT_API_DO_NOT_USE
	# define unorm2_append unorm2_append_DRAFT_API_DO_NOT_USE		# define unorm2_append unorm2_append_DRAFT_API_DO_NOT_USE
	# define unorm2_close unorm2_close_DRAFT_API_DO_NOT_USE		# define unorm2_close unorm2_close_DRAFT_API_DO_NOT_USE
			# define unorm2_getDecomposition unorm2_getDecomposition_DRAFT_API_D O_NOT_USE
	# define unorm2_getInstance unorm2_getInstance_DRAFT_API_DO_NOT_USE		# define unorm2_getInstance unorm2_getInstance_DRAFT_API_DO_NOT_USE
	# define unorm2_hasBoundaryAfter unorm2_hasBoundaryAfter_DRAFT_API_D O_NOT_USE		# define unorm2_hasBoundaryAfter unorm2_hasBoundaryAfter_DRAFT_API_D O_NOT_USE
	# define unorm2_hasBoundaryBefore unorm2_hasBoundaryBefore_DRAFT_API _DO_NOT_USE		# define unorm2_hasBoundaryBefore unorm2_hasBoundaryBefore_DRAFT_API _DO_NOT_USE
	# define unorm2_isInert unorm2_isInert_DRAFT_API_DO_NOT_USE		# define unorm2_isInert unorm2_isInert_DRAFT_API_DO_NOT_USE
	# define unorm2_isNormalized unorm2_isNormalized_DRAFT_API_DO_NOT_US E		# define unorm2_isNormalized unorm2_isNormalized_DRAFT_API_DO_NOT_US E
	# define unorm2_normalize unorm2_normalize_DRAFT_API_DO_NOT_USE		# define unorm2_normalize unorm2_normalize_DRAFT_API_DO_NOT_USE
	# define unorm2_normalizeSecondAndAppend unorm2_normalizeSecondAndAp pend_DRAFT_API_DO_NOT_USE		# define unorm2_normalizeSecondAndAppend unorm2_normalizeSecondAndAp pend_DRAFT_API_DO_NOT_USE
	# define unorm2_openFiltered unorm2_openFiltered_DRAFT_API_DO_NOT_US E		# define unorm2_openFiltered unorm2_openFiltered_DRAFT_API_DO_NOT_US E
	# define unorm2_quickCheck unorm2_quickCheck_DRAFT_API_DO_NOT_USE		# define unorm2_quickCheck unorm2_quickCheck_DRAFT_API_DO_NOT_USE
	# define unorm2_spanQuickCheckYes unorm2_spanQuickCheckYes_DRAFT_API _DO_NOT_USE		# define unorm2_spanQuickCheckYes unorm2_spanQuickCheckYes_DRAFT_API _DO_NOT_USE
	# define unum_formatDecimal unum_formatDecimal_DRAFT_API_DO_NOT_USE		# define unum_formatDecimal unum_formatDecimal_DRAFT_API_DO_NOT_USE
	# define unum_parseDecimal unum_parseDecimal_DRAFT_API_DO_NOT_USE		# define unum_parseDecimal unum_parseDecimal_DRAFT_API_DO_NOT_USE
			# define uregex_getFindProgressCallback uregex_getFindProgressCallba
			ck_DRAFT_API_DO_NOT_USE
			# define uregex_setFindProgressCallback uregex_setFindProgressCallba
			ck_DRAFT_API_DO_NOT_USE
	# else		# else
	# define bamuScriptCode_4_4 bamuScriptCode_DRAFT_API_DO_NOT_USE		# define bamuScriptCode_4_5 bamuScriptCode_DRAFT_API_DO_NOT_USE
	# define u_fadopt_4_4 u_fadopt_DRAFT_API_DO_NOT_USE		# define u_fadopt_4_5 u_fadopt_DRAFT_API_DO_NOT_USE
	# define u_strFromJavaModifiedUTF8WithSub_4_4 u_strFromJavaModifiedU		# define u_strFromJavaModifiedUTF8WithSub_4_5 u_strFromJavaModifiedU
	TF8WithSub_DRAFT_API_DO_NOT_USE		TF8WithSub_DRAFT_API_DO_NOT_USE
	# define u_strToJavaModifiedUTF8_4_4 u_strToJavaModifiedUTF8_DRAFT_A		# define u_strToJavaModifiedUTF8_4_5 u_strToJavaModifiedUTF8_DRAFT_A
	PI_DO_NOT_USE		PI_DO_NOT_USE
	# define ucal_getDayOfWeekType_4_4 ucal_getDayOfWeekType_DRAFT_API_D		# define ucal_getDayOfWeekType_4_5 ucal_getDayOfWeekType_DRAFT_API_D
	O_NOT_USE		O_NOT_USE
	# define ucal_getWeekendTransition_4_4 ucal_getWeekendTransition_DRA		# define ucal_getWeekendTransition_4_5 ucal_getWeekendTransition_DRA
	FT_API_DO_NOT_USE		FT_API_DO_NOT_USE
	# define ucal_isWeekend_4_4 ucal_isWeekend_DRAFT_API_DO_NOT_USE		# define ucal_isWeekend_4_5 ucal_isWeekend_DRAFT_API_DO_NOT_USE
	# define udat_toCalendarDateField_4_4 udat_toCalendarDateField_DRAFT		# define udat_toCalendarDateField_4_5 udat_toCalendarDateField_DRAFT
	_API_DO_NOT_USE		_API_DO_NOT_USE
	# define udatpg_getBestPatternWithOptions_4_4 udatpg_getBestPatternW		# define udatpg_getBestPatternWithOptions_4_5 udatpg_getBestPatternW
	ithOptions_DRAFT_API_DO_NOT_USE		ithOptions_DRAFT_API_DO_NOT_USE
	# define udatpg_replaceFieldTypesWithOptions_4_4 udatpg_replaceField		# define udatpg_replaceFieldTypesWithOptions_4_5 udatpg_replaceField
	TypesWithOptions_DRAFT_API_DO_NOT_USE		TypesWithOptions_DRAFT_API_DO_NOT_USE
	# define uldn_close_4_4 uldn_close_DRAFT_API_DO_NOT_USE		# define uidna_close_4_5 uidna_close_DRAFT_API_DO_NOT_USE
	# define uldn_getDialectHandling_4_4 uldn_getDialectHandling_DRAFT_A		# define uidna_labelToASCII_4_5 uidna_labelToASCII_DRAFT_API_DO_NOT_
	PI_DO_NOT_USE		USE
	# define uldn_getLocale_4_4 uldn_getLocale_DRAFT_API_DO_NOT_USE		# define uidna_labelToASCII_UTF8_4_5 uidna_labelToASCII_UTF8_DRAFT_A
	# define uldn_keyDisplayName_4_4 uldn_keyDisplayName_DRAFT_API_DO_NO		PI_DO_NOT_USE
	T_USE		# define uidna_labelToUnicodeUTF8_4_5 uidna_labelToUnicodeUTF8_DRAFT
	# define uldn_keyValueDisplayName_4_4 uldn_keyValueDisplayName_DRAFT		_API_DO_NOT_USE
	_API_DO_NOT_USE		# define uidna_labelToUnicode_4_5 uidna_labelToUnicode_DRAFT_API_DO_
	# define uldn_languageDisplayName_4_4 uldn_languageDisplayName_DRAFT		NOT_USE
	_API_DO_NOT_USE		# define uidna_nameToASCII_4_5 uidna_nameToASCII_DRAFT_API_DO_NOT_US
	# define uldn_localeDisplayName_4_4 uldn_localeDisplayName_DRAFT_API		E
	_DO_NOT_USE		# define uidna_nameToASCII_UTF8_4_5 uidna_nameToASCII_UTF8_DRAFT_API
	# define uldn_open_4_4 uldn_open_DRAFT_API_DO_NOT_USE		_DO_NOT_USE
	# define uldn_regionDisplayName_4_4 uldn_regionDisplayName_DRAFT_API		# define uidna_nameToUnicodeUTF8_4_5 uidna_nameToUnicodeUTF8_DRAFT_A
	_DO_NOT_USE		PI_DO_NOT_USE
	# define uldn_scriptCodeDisplayName_4_4 uldn_scriptCodeDisplayName_D		# define uidna_nameToUnicode_4_5 uidna_nameToUnicode_DRAFT_API_DO_NO
	RAFT_API_DO_NOT_USE		T_USE
	# define uldn_scriptDisplayName_4_4 uldn_scriptDisplayName_DRAFT_API		# define uidna_openUTS46_4_5 uidna_openUTS46_DRAFT_API_DO_NOT_USE
	_DO_NOT_USE		# define uldn_close_4_5 uldn_close_DRAFT_API_DO_NOT_USE
	# define uldn_variantDisplayName_4_4 uldn_variantDisplayName_DRAFT_A		# define uldn_getDialectHandling_4_5 uldn_getDialectHandling_DRAFT_A
	PI_DO_NOT_USE		PI_DO_NOT_USE
	# define uloc_forLanguageTag_4_4 uloc_forLanguageTag_DRAFT_API_DO_NO		# define uldn_getLocale_4_5 uldn_getLocale_DRAFT_API_DO_NOT_USE
	T_USE		# define uldn_keyDisplayName_4_5 uldn_keyDisplayName_DRAFT_API_DO_NO
	# define uloc_toLanguageTag_4_4 uloc_toLanguageTag_DRAFT_API_DO_NOT_		T_USE
	USE		# define uldn_keyValueDisplayName_4_5 uldn_keyValueDisplayName_DRAFT
	# define unorm2_append_4_4 unorm2_append_DRAFT_API_DO_NOT_USE		_API_DO_NOT_USE
	# define unorm2_close_4_4 unorm2_close_DRAFT_API_DO_NOT_USE		# define uldn_languageDisplayName_4_5 uldn_languageDisplayName_DRAFT
	# define unorm2_getInstance_4_4 unorm2_getInstance_DRAFT_API_DO_NOT_		_API_DO_NOT_USE
	USE		# define uldn_localeDisplayName_4_5 uldn_localeDisplayName_DRAFT_API
	# define unorm2_hasBoundaryAfter_4_4 unorm2_hasBoundaryAfter_DRAFT_A		_DO_NOT_USE
	PI_DO_NOT_USE		# define uldn_open_4_5 uldn_open_DRAFT_API_DO_NOT_USE
	# define unorm2_hasBoundaryBefore_4_4 unorm2_hasBoundaryBefore_DRAFT		# define uldn_regionDisplayName_4_5 uldn_regionDisplayName_DRAFT_API
	_API_DO_NOT_USE		_DO_NOT_USE
	# define unorm2_isInert_4_4 unorm2_isInert_DRAFT_API_DO_NOT_USE		# define uldn_scriptCodeDisplayName_4_5 uldn_scriptCodeDisplayName_D
	# define unorm2_isNormalized_4_4 unorm2_isNormalized_DRAFT_API_DO_NO		RAFT_API_DO_NOT_USE
	T_USE		# define uldn_scriptDisplayName_4_5 uldn_scriptDisplayName_DRAFT_API
	# define unorm2_normalizeSecondAndAppend_4_4 unorm2_normalizeSecondA		_DO_NOT_USE
	ndAppend_DRAFT_API_DO_NOT_USE		# define uldn_variantDisplayName_4_5 uldn_variantDisplayName_DRAFT_A
	# define unorm2_normalize_4_4 unorm2_normalize_DRAFT_API_DO_NOT_USE		PI_DO_NOT_USE
	# define unorm2_openFiltered_4_4 unorm2_openFiltered_DRAFT_API_DO_NO		# define uloc_forLanguageTag_4_5 uloc_forLanguageTag_DRAFT_API_DO_NO
	T_USE		T_USE
	# define unorm2_quickCheck_4_4 unorm2_quickCheck_DRAFT_API_DO_NOT_US		# define uloc_toLanguageTag_4_5 uloc_toLanguageTag_DRAFT_API_DO_NOT_
	E		USE
	# define unorm2_spanQuickCheckYes_4_4 unorm2_spanQuickCheckYes_DRAFT		# define unorm2_append_4_5 unorm2_append_DRAFT_API_DO_NOT_USE
	_API_DO_NOT_USE		# define unorm2_close_4_5 unorm2_close_DRAFT_API_DO_NOT_USE
	# define unum_formatDecimal_4_4 unum_formatDecimal_DRAFT_API_DO_NOT_		# define unorm2_getDecomposition_4_5 unorm2_getDecomposition_DRAFT_A
	USE		PI_DO_NOT_USE
	# define unum_parseDecimal_4_4 unum_parseDecimal_DRAFT_API_DO_NOT_US		# define unorm2_getInstance_4_5 unorm2_getInstance_DRAFT_API_DO_NOT_
	E		USE
			# define unorm2_hasBoundaryAfter_4_5 unorm2_hasBoundaryAfter_DRAFT_A
			PI_DO_NOT_USE
			# define unorm2_hasBoundaryBefore_4_5 unorm2_hasBoundaryBefore_DRAFT
			_API_DO_NOT_USE
			# define unorm2_isInert_4_5 unorm2_isInert_DRAFT_API_DO_NOT_USE
			# define unorm2_isNormalized_4_5 unorm2_isNormalized_DRAFT_API_DO_NO
			T_USE
			# define unorm2_normalizeSecondAndAppend_4_5 unorm2_normalizeSecondA
			ndAppend_DRAFT_API_DO_NOT_USE
			# define unorm2_normalize_4_5 unorm2_normalize_DRAFT_API_DO_NOT_USE
			# define unorm2_openFiltered_4_5 unorm2_openFiltered_DRAFT_API_DO_NO
			T_USE
			# define unorm2_quickCheck_4_5 unorm2_quickCheck_DRAFT_API_DO_NOT_US
			E
			# define unorm2_spanQuickCheckYes_4_5 unorm2_spanQuickCheckYes_DRAFT
			_API_DO_NOT_USE
			# define unum_formatDecimal_4_5 unum_formatDecimal_DRAFT_API_DO_NOT_
			USE
			# define unum_parseDecimal_4_5 unum_parseDecimal_DRAFT_API_DO_NOT_US
			E
			# define uregex_getFindProgressCallback_4_5 uregex_getFindProgressCa
			llback_DRAFT_API_DO_NOT_USE
			# define uregex_setFindProgressCallback_4_5 uregex_setFindProgressCa
			llback_DRAFT_API_DO_NOT_USE
	# endif /* U_DISABLE_RENAMING */		# endif /* U_DISABLE_RENAMING */
	#endif /* U_HIDE_DRAFT_API */		#endif /* U_HIDE_DRAFT_API */
	#endif /* UDRAFT_H */		#endif /* UDRAFT_H */
End of changes. 4 change blocks.
	66 lines changed or deleted		111 lines changed or added

	uidna.h		uidna.h
	skipping to change at line 24		skipping to change at line 24
	* created by: Ram Viswanadha		* created by: Ram Viswanadha
	*/		*/
	#ifndef __UIDNA_H__		#ifndef __UIDNA_H__
	#define __UIDNA_H__		#define __UIDNA_H__
	#include "unicode/utypes.h"		#include "unicode/utypes.h"
	#if !UCONFIG_NO_IDNA		#if !UCONFIG_NO_IDNA
			#include "unicode/localpointer.h"
	#include "unicode/parseerr.h"		#include "unicode/parseerr.h"
	/**		/**
	* \file		* \file
	* \brief C API: Internationalized Domain Names in Applications Tranformati on		* \brief C API: Internationalizing Domain Names in Applications (IDNA)
	*		*
	* UIDNA API implements the IDNA protocol as defined in the IDNA RFC		* IDNA2008 is implemented according to UTS #46, see the IDNA C++ class in
	* (http://www.ietf.org/rfc/rfc3490.txt).		idna.h.
	* The RFC defines 2 operations: ToASCII and ToUnicode. Domain labels
	* containing non-ASCII code points are required to be processed by
	* ToASCII operation before passing it to resolver libraries. Domain names
	* that are obtained from resolver libraries are required to be processed b
	y
	* ToUnicode operation before displaying the domain name to the user.
	* IDNA requires that implementations process input strings with Nameprep
	* (http://www.ietf.org/rfc/rfc3491.txt),
	* which is a profile of Stringprep (http://www.ietf.org/rfc/rfc3454.txt),
	* and then with Punycode (http://www.ietf.org/rfc/rfc3492.txt).
	* Implementations of IDNA MUST fully implement Nameprep and Punycode;
	* neither Nameprep nor Punycode are optional.
	* The input and output of ToASCII and ToUnicode operations are Unicode
	* and are designed to be chainable, i.e., applying ToASCII or ToUnicode op
	erations
	* multiple times to an input string will yield the same result as applying
	the operation
	* once.
	* ToUnicode(ToUnicode(ToUnicode...(ToUnicode(string)))) == ToUnicode(strin
	g)
	* ToASCII(ToASCII(ToASCII...(ToASCII(string))) == ToASCII(string).
	*		*
			* The C API functions which do take a UIDNA * service object pointer
			* implement UTS #46 and IDNA2008.
			* The C API functions which do not take a service object pointer
			* implement IDNA2003.
			*/
			/*
			* IDNA option bit set values.
			*/
			enum {
			/**
			* Default options value: None of the other options are set.
			* @stable ICU 2.6
			*/
			UIDNA_DEFAULT=0,
			/**
			* Option to allow unassigned code points in domain names and labels.
			* This option is ignored by the UTS46 implementation.
			* (UTS #46 disallows unassigned code points.)
			* @stable ICU 2.6
			*/
			UIDNA_ALLOW_UNASSIGNED=1,
			/**
			* Option to check whether the input conforms to the STD3 ASCII rules,
			* for example the restriction of labels to LDH characters
			* (ASCII Letters, Digits and Hyphen-Minus).
			* @stable ICU 2.6
			*/
			UIDNA_USE_STD3_RULES=2,
			/**
			* IDNA option to check for whether the input conforms to the BiDi rule
			s.
			* This option is ignored by the IDNA2003 implementation.
			* (IDNA2003 always performs a BiDi check.)
			* @draft ICU 4.6
			*/
			UIDNA_CHECK_BIDI=4,
			/**
			* IDNA option to check for whether the input conforms to the CONTEXTJ
			rules.
			* This option is ignored by the IDNA2003 implementation.
			* (The CONTEXTJ check is new in IDNA2008.)
			* @draft ICU 4.6
			*/
			UIDNA_CHECK_CONTEXTJ=8,
			/**
			* IDNA option for nontransitional processing in ToASCII().
			* By default, ToASCII() uses transitional processing.
			* This option is ignored by the IDNA2003 implementation.
			* (This is only relevant for compatibility of newer IDNA implementatio
			ns with IDNA2003.)
			* @draft ICU 4.6
			*/
			UIDNA_NONTRANSITIONAL_TO_ASCII=0x10,
			/**
			* IDNA option for nontransitional processing in ToUnicode().
			* By default, ToUnicode() uses transitional processing.
			* This option is ignored by the IDNA2003 implementation.
			* (This is only relevant for compatibility of newer IDNA implementatio
			ns with IDNA2003.)
			* @draft ICU 4.6
			*/
			UIDNA_NONTRANSITIONAL_TO_UNICODE=0x20
			};
			/**
			* Opaque C service object type for the new IDNA API.
			* @draft ICU 4.6
	*/		*/
			struct UIDNA;
			typedef struct UIDNA UIDNA; /**< C typedef for struct UIDNA. @draft ICU 4.
			6 */
	/**		/**
	* Option to prohibit processing of unassigned codepoints in the input and		* Returns a UIDNA instance which implements UTS #46.
	* do not check if the input conforms to STD-3 ASCII rules.		* Returns an unmodifiable instance, owned by the caller.
			* Cache it for multiple operations, and uidna_close() it when done.
	*		*
	* @see uidna_toASCII uidna_toUnicode		* For details about the UTS #46 implementation see the IDNA C++ class in i
	* @stable ICU 2.6		dna.h.
			*
			* @param options Bit set to modify the processing and error checking.
			* See option bit set values in uidna.h.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return the UTS #46 UIDNA instance, if successful
			* @draft ICU 4.6
	*/		*/
	#define UIDNA_DEFAULT 0x0000		U_DRAFT UIDNA * U_EXPORT2
			uidna_openUTS46(uint32_t options, UErrorCode *pErrorCode);
	/**		/**
	* Option to allow processing of unassigned codepoints in the input		* Closes a UIDNA instance.
			* @param idna UIDNA instance to be closed
			* @draft ICU 4.6
			*/
			U_DRAFT void U_EXPORT2
			uidna_close(UIDNA *idna);
			#if U_SHOW_CPLUSPLUS_API
			U_NAMESPACE_BEGIN
			/**
			* \class LocalUIDNAPointer
			* "Smart pointer" class, closes a UIDNA via uidna_close().
			* For most methods see the LocalPointerBase base class.
	*		*
	* @see uidna_toASCII uidna_toUnicode		* @see LocalPointerBase
	* @stable ICU 2.6		* @see LocalPointer
			* @draft ICU 4.6
	*/		*/
	#define UIDNA_ALLOW_UNASSIGNED 0x0001		U_DEFINE_LOCAL_OPEN_POINTER(LocalUIDNAPointer, UIDNA, uidna_close);
			U_NAMESPACE_END
			#endif
	/**		/**
	* Option to check if input conforms to STD-3 ASCII rules		* Output container for IDNA processing errors.
			* Initialize with UIDNA_INFO_INITIALIZER:
			* \code
			* UIDNAInfo info = UIDNA_INFO_INITIALIZER;
			* int32_t length = uidna_nameToASCII(..., &info, &errorCode);
			* if(U_SUCCESS(errorCode) && info.errors!=0) { ... }
			* \endcode
			* @draft ICU 4.6
			*/
			struct UIDNAInfo {
			/** sizeof(UIDNAInfo) @draft ICU 4.6 */
			int16_t size;
			/**
			* Set to TRUE if transitional and nontransitional processing produce d
			ifferent results.
			* For details see C++ IDNAInfo::isTransitionalDifferent().
			* @draft ICU 4.6
			*/
			UBool isTransitionalDifferent;
			UBool reservedB3; /**< Reserved field, do not use. @internal */
			/**
			* Bit set indicating IDNA processing errors. 0 if no errors.
			* See UIDNA_ERROR_... constants.
			* @draft ICU 4.6
			*/
			uint32_t errors;
			int32_t reservedI2; /**< Reserved field, do not use. @internal */
			int32_t reservedI3; /**< Reserved field, do not use. @internal */
			};
			typedef struct UIDNAInfo UIDNAInfo;
			/**
			* Static initializer for a UIDNAInfo struct.
			* @draft ICU 4.6
			*/
			#define UIDNA_INFO_INITIALIZER { \
			(int16_t)sizeof(UIDNAInfo), \
			FALSE, FALSE, \
			0, 0, 0 }
			/**
			* Converts a single domain name label into its ASCII form for DNS lookup.
			* If any processing step fails, then pInfo->errors will be non-zero and
			* the result might not be an ASCII string.
			* The label might be modified according to the types of errors.
			* Labels with severe errors will be left in (or turned into) their Unicode
			form.
	*		*
	* @see uidna_toASCII uidna_toUnicode		* The UErrorCode indicates an error only in exceptional cases,
	* @stable ICU 2.6		* such as a U_MEMORY_ALLOCATION_ERROR.
			*
			* @param idna UIDNA instance
			* @param label Input domain name label
			* @param length Label length, or -1 if NUL-terminated
			* @param dest Destination string buffer
			* @param capacity Destination buffer capacity
			* @param pInfo Output container of IDNA processing details.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return destination string length
			* @draft ICU 4.6
	*/		*/
	#define UIDNA_USE_STD3_RULES 0x0002		U_DRAFT int32_t U_EXPORT2
			uidna_labelToASCII(const UIDNA *idna,
			const UChar *label, int32_t length,
			UChar *dest, int32_t capacity,
			UIDNAInfo *pInfo, UErrorCode *pErrorCode);
	/**		/**
	* This function implements the ToASCII operation as defined in the IDNA RF		* Converts a single domain name label into its Unicode form for human-read
	C.		able display.
			* If any processing step fails, then pInfo->errors will be non-zero.
			* The domain name might be modified according to the types of errors.
			*
			* The UErrorCode indicates an error only in exceptional cases,
			* such as a U_MEMORY_ALLOCATION_ERROR.
			*
			* @param idna UIDNA instance
			* @param label Input domain name label
			* @param length Label length, or -1 if NUL-terminated
			* @param dest Destination string buffer
			* @param capacity Destination buffer capacity
			* @param pInfo Output container of IDNA processing details.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return destination string length
			* @draft ICU 4.6
			*/
			U_DRAFT int32_t U_EXPORT2
			uidna_labelToUnicode(const UIDNA *idna,
			const UChar *label, int32_t length,
			UChar *dest, int32_t capacity,
			UIDNAInfo *pInfo, UErrorCode *pErrorCode);
			/**
			* Converts a whole domain name into its ASCII form for DNS lookup.
			* If any processing step fails, then pInfo->errors will be non-zero and
			* the result might not be an ASCII string.
			* The domain name might be modified according to the types of errors.
			* Labels with severe errors will be left in (or turned into) their Unicode
			form.
			*
			* The UErrorCode indicates an error only in exceptional cases,
			* such as a U_MEMORY_ALLOCATION_ERROR.
			*
			* @param idna UIDNA instance
			* @param name Input domain name
			* @param length Domain name length, or -1 if NUL-terminated
			* @param dest Destination string buffer
			* @param capacity Destination buffer capacity
			* @param pInfo Output container of IDNA processing details.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return destination string length
			* @draft ICU 4.6
			*/
			U_DRAFT int32_t U_EXPORT2
			uidna_nameToASCII(const UIDNA *idna,
			const UChar *name, int32_t length,
			UChar *dest, int32_t capacity,
			UIDNAInfo *pInfo, UErrorCode *pErrorCode);
			/**
			* Converts a whole domain name into its Unicode form for human-readable di
			splay.
			* If any processing step fails, then pInfo->errors will be non-zero.
			* The domain name might be modified according to the types of errors.
			*
			* The UErrorCode indicates an error only in exceptional cases,
			* such as a U_MEMORY_ALLOCATION_ERROR.
			*
			* @param idna UIDNA instance
			* @param name Input domain name
			* @param length Domain name length, or -1 if NUL-terminated
			* @param dest Destination string buffer
			* @param capacity Destination buffer capacity
			* @param pInfo Output container of IDNA processing details.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return destination string length
			* @draft ICU 4.6
			*/
			U_DRAFT int32_t U_EXPORT2
			uidna_nameToUnicode(const UIDNA *idna,
			const UChar *name, int32_t length,
			UChar *dest, int32_t capacity,
			UIDNAInfo *pInfo, UErrorCode *pErrorCode);
			/* UTF-8 versions of the processing methods -------------------------------
			-- */
			/**
			* Converts a single domain name label into its ASCII form for DNS lookup.
			* UTF-8 version of uidna_labelToASCII(), same behavior.
			*
			* @param idna UIDNA instance
			* @param label Input domain name label
			* @param length Label length, or -1 if NUL-terminated
			* @param dest Destination string buffer
			* @param capacity Destination buffer capacity
			* @param pInfo Output container of IDNA processing details.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return destination string length
			* @draft ICU 4.6
			*/
			U_DRAFT int32_t U_EXPORT2
			uidna_labelToASCII_UTF8(const UIDNA *idna,
			const char *label, int32_t length,
			char *dest, int32_t capacity,
			UIDNAInfo *pInfo, UErrorCode *pErrorCode);
			/**
			* Converts a single domain name label into its Unicode form for human-read
			able display.
			* UTF-8 version of uidna_labelToUnicode(), same behavior.
			*
			* @param idna UIDNA instance
			* @param label Input domain name label
			* @param length Label length, or -1 if NUL-terminated
			* @param dest Destination string buffer
			* @param capacity Destination buffer capacity
			* @param pInfo Output container of IDNA processing details.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return destination string length
			* @draft ICU 4.6
			*/
			U_DRAFT int32_t U_EXPORT2
			uidna_labelToUnicodeUTF8(const UIDNA *idna,
			const char *label, int32_t length,
			char *dest, int32_t capacity,
			UIDNAInfo *pInfo, UErrorCode *pErrorCode);
			/**
			* Converts a whole domain name into its ASCII form for DNS lookup.
			* UTF-8 version of uidna_nameToASCII(), same behavior.
			*
			* @param idna UIDNA instance
			* @param name Input domain name
			* @param length Domain name length, or -1 if NUL-terminated
			* @param dest Destination string buffer
			* @param capacity Destination buffer capacity
			* @param pInfo Output container of IDNA processing details.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return destination string length
			* @draft ICU 4.6
			*/
			U_DRAFT int32_t U_EXPORT2
			uidna_nameToASCII_UTF8(const UIDNA *idna,
			const char *name, int32_t length,
			char *dest, int32_t capacity,
			UIDNAInfo *pInfo, UErrorCode *pErrorCode);
			/**
			* Converts a whole domain name into its Unicode form for human-readable di
			splay.
			* UTF-8 version of uidna_nameToUnicode(), same behavior.
			*
			* @param idna UIDNA instance
			* @param name Input domain name
			* @param length Domain name length, or -1 if NUL-terminated
			* @param dest Destination string buffer
			* @param capacity Destination buffer capacity
			* @param pInfo Output container of IDNA processing details.
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function returns
			* immediately. Check for U_FAILURE() on output or use wit
			h
			* function chaining. (See User Guide for details.)
			* @return destination string length
			* @draft ICU 4.6
			*/
			U_DRAFT int32_t U_EXPORT2
			uidna_nameToUnicodeUTF8(const UIDNA *idna,
			const char *name, int32_t length,
			char *dest, int32_t capacity,
			UIDNAInfo *pInfo, UErrorCode *pErrorCode);
			/*
			* IDNA error bit set values.
			* When a domain name or label fails a processing step or does not meet the
			* validity criteria, then one or more of these error bits are set.
			*/
			enum {
			/**
			* A non-final domain name label (or the whole domain name) is empty.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_EMPTY_LABEL=1,
			/**
			* A domain name label is longer than 63 bytes.
			* (See STD13/RFC1034 3.1. Name space specifications and terminology.)
			* This is only checked in ToASCII operations, and only if the UIDNA_US
			E_STD3_RULES is set.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_LABEL_TOO_LONG=2,
			/**
			* A domain name is longer than 255 bytes in its storage form.
			* (See STD13/RFC1034 3.1. Name space specifications and terminology.)
			* This is only checked in ToASCII operations, and only if the UIDNA_US
			E_STD3_RULES is set.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_DOMAIN_NAME_TOO_LONG=4,
			/**
			* A label starts with a hyphen-minus ('-').
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_LEADING_HYPHEN=8,
			/**
			* A label ends with a hyphen-minus ('-').
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_TRAILING_HYPHEN=0x10,
			/**
			* A label contains hyphen-minus ('-') in the third and fourth position
			s.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_HYPHEN_3_4=0x20,
			/**
			* A label starts with a combining mark.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_LEADING_COMBINING_MARK=0x40,
			/**
			* A label or domain name contains disallowed characters.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_DISALLOWED=0x80,
			/**
			* A label starts with "xn--" but does not contain valid Punycode.
			* That is, an xn-- label failed Punycode decoding.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_PUNYCODE=0x100,
			/**
			* A label contains a dot=full stop.
			* This can occur in an input string for a single-label function.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_LABEL_HAS_DOT=0x200,
			/**
			* An ACE label does not contain a valid label string.
			* The label was successfully ACE (Punycode) decoded but the resulting
			* string had severe validation errors. For example,
			* it might contain characters that are not allowed in ACE labels,
			* or it might not be normalized.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_INVALID_ACE_LABEL=0x400,
			/**
			* A label does not meet the IDNA BiDi requirements (for right-to-left
			characters).
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_BIDI=0x800,
			/**
			* A label does not meet the IDNA CONTEXTJ requirements.
			* @draft ICU 4.6
			*/
			UIDNA_ERROR_CONTEXTJ=0x1000
			};
			/* IDNA2003 API -----------------------------------------------------------
			-- */
			/**
			* IDNA2003: This function implements the ToASCII operation as defined in t
			he IDNA RFC.
	* This operation is done on <b>single labels</b> before sending it to some thing that expects		* This operation is done on <b>single labels</b> before sending it to some thing that expects
	* ASCII names. A label is an individual part of a domain name. Labels are usually		* ASCII names. A label is an individual part of a domain name. Labels are usually
	* separated by dots; e.g. "www.example.com" is composed of 3 labels "www", "example", and "com".		* separated by dots; e.g. "www.example.com" is composed of 3 labels "www", "example", and "com".
	*		*
			* IDNA2003 API Overview:
			*
			* The uidna_ API implements the IDNA protocol as defined in the IDNA RFC
			* (http://www.ietf.org/rfc/rfc3490.txt).
			* The RFC defines 2 operations: ToASCII and ToUnicode. Domain name labels
			* containing non-ASCII code points are processed by the
			* ToASCII operation before passing it to resolver libraries. Domain names
			* that are obtained from resolver libraries are processed by the
			* ToUnicode operation before displaying the domain name to the user.
			* IDNA requires that implementations process input strings with Nameprep
			* (http://www.ietf.org/rfc/rfc3491.txt),
			* which is a profile of Stringprep (http://www.ietf.org/rfc/rfc3454.txt),
			* and then with Punycode (http://www.ietf.org/rfc/rfc3492.txt).
			* Implementations of IDNA MUST fully implement Nameprep and Punycode;
			* neither Nameprep nor Punycode are optional.
			* The input and output of ToASCII and ToUnicode operations are Unicode
			* and are designed to be chainable, i.e., applying ToASCII or ToUnicode op
			erations
			* multiple times to an input string will yield the same result as applying
			the operation
			* once.
			* ToUnicode(ToUnicode(ToUnicode...(ToUnicode(string)))) == ToUnicode(strin
			g)
			* ToASCII(ToASCII(ToASCII...(ToASCII(string))) == ToASCII(string).
	*		*
	* @param src Input UChar array containing label in Unicode.		* @param src Input UChar array containing label in Unicode.
	* @param srcLength Number of UChars in src, or -1 if NUL-terminate d.		* @param srcLength Number of UChars in src, or -1 if NUL-terminate d.
	* @param dest Output UChar array with ASCII (ACE encoded) lab el.		* @param dest Output UChar array with ASCII (ACE encoded) lab el.
	* @param destCapacity Size of dest.		* @param destCapacity Size of dest.
	* @param options A bit set of options:		* @param options A bit set of options:
	*		*
	* - UIDNA_DEFAULT Use default options, i.e., do not process u nassigned code points		* - UIDNA_DEFAULT Use default options, i.e., do not process u nassigned code points
	* and do not use STD3 ASCII rules		* and do not use STD3 ASCII rules
	* If unassigned code points are found the ope ration fails with		* If unassigned code points are found the ope ration fails with
	skipping to change at line 121		skipping to change at line 545
	* @stable ICU 2.6		* @stable ICU 2.6
	*/		*/
	U_STABLE int32_t U_EXPORT2		U_STABLE int32_t U_EXPORT2
	uidna_toASCII(const UChar* src, int32_t srcLength,		uidna_toASCII(const UChar* src, int32_t srcLength,
	UChar* dest, int32_t destCapacity,		UChar* dest, int32_t destCapacity,
	int32_t options,		int32_t options,
	UParseError* parseError,		UParseError* parseError,
	UErrorCode* status);		UErrorCode* status);
	/**		/**
	* This function implements the ToUnicode operation as defined in the IDNA RFC.		* IDNA2003: This function implements the ToUnicode operation as defined in the IDNA RFC.
	* This operation is done on <b>single labels</b> before sending it to some thing that expects		* This operation is done on <b>single labels</b> before sending it to some thing that expects
	* Unicode names. A label is an individual part of a domain name. Labels ar e usually		* Unicode names. A label is an individual part of a domain name. Labels ar e usually
	* separated by dots; for e.g. "www.example.com" is composed of 3 labels "w ww","example", and "com".		* separated by dots; for e.g. "www.example.com" is composed of 3 labels "w ww","example", and "com".
	*		*
	* @param src Input UChar array containing ASCII (ACE encoded ) label.		* @param src Input UChar array containing ASCII (ACE encoded ) label.
	* @param srcLength Number of UChars in src, or -1 if NUL-terminate d.		* @param srcLength Number of UChars in src, or -1 if NUL-terminate d.
	* @param dest Output Converted UChar array containing Unicode equiva lent of label.		* @param dest Output Converted UChar array containing Unicode equiva lent of label.
	* @param destCapacity Size of dest.		* @param destCapacity Size of dest.
	* @param options A bit set of options:		* @param options A bit set of options:
	*		*
	skipping to change at line 144		skipping to change at line 568
	* If unassigned code points are found the ope ration fails with		* If unassigned code points are found the ope ration fails with
	* U_UNASSIGNED_ERROR error code.		* U_UNASSIGNED_ERROR error code.
	*		*
	* - UIDNA_ALLOW_UNASSIGNED Unassigned values can be converted to ASC II for query operations		* - UIDNA_ALLOW_UNASSIGNED Unassigned values can be converted to ASC II for query operations
	* If this option is set, the unassigned code points are in the input		* If this option is set, the unassigned code points are in the input
	* are treated as normal Unicode code points. <b> Note: </b> This option is		* are treated as normal Unicode code points. <b> Note: </b> This option is
	* required on toUnicode operation because the RFC mandates		* required on toUnicode operation because the RFC mandates
	* verification of decoded ACE input by applyi ng toASCII and comparing		* verification of decoded ACE input by applyi ng toASCII and comparing
	* its output with source		* its output with source
	*		*
	*
	*
	* - UIDNA_USE_STD3_RULES Use STD3 ASCII rules for host name syntax r estrictions		* - UIDNA_USE_STD3_RULES Use STD3 ASCII rules for host name syntax r estrictions
	* If this option is set and the input does no t satisfy STD3 rules,		* If this option is set and the input does no t satisfy STD3 rules,
	* the operation will fail with U_IDNA_STD3_AS CII_RULES_ERROR		* the operation will fail with U_IDNA_STD3_AS CII_RULES_ERROR
	*		*
	* @param parseError Pointer to UParseError struct to receive inform ation on position		* @param parseError Pointer to UParseError struct to receive inform ation on position
	* of error if an error is encountered. Can be NUL L.		* of error if an error is encountered. Can be NUL L.
	* @param status ICU in/out error code parameter.		* @param status ICU in/out error code parameter.
	* U_INVALID_CHAR_FOUND if src contains		* U_INVALID_CHAR_FOUND if src contains
	* unmatched single surrogates.		* unmatched single surrogates.
	* U_INDEX_OUTOFBOUNDS_ERROR if src contains		* U_INDEX_OUTOFBOUNDS_ERROR if src contains
	skipping to change at line 170		skipping to change at line 592
	* @stable ICU 2.6		* @stable ICU 2.6
	*/		*/
	U_STABLE int32_t U_EXPORT2		U_STABLE int32_t U_EXPORT2
	uidna_toUnicode(const UChar* src, int32_t srcLength,		uidna_toUnicode(const UChar* src, int32_t srcLength,
	UChar* dest, int32_t destCapacity,		UChar* dest, int32_t destCapacity,
	int32_t options,		int32_t options,
	UParseError* parseError,		UParseError* parseError,
	UErrorCode* status);		UErrorCode* status);
	/**		/**
	* Convenience function that implements the IDNToASCII operation as defined in the IDNA RFC.		* IDNA2003: Convenience function that implements the IDNToASCII operation as defined in the IDNA RFC.
	* This operation is done on complete domain names, e.g: "www.example.com".		* This operation is done on complete domain names, e.g: "www.example.com".
	* It is important to note that this operation can fail. If it fails, then the input		* It is important to note that this operation can fail. If it fails, then the input
	* domain name cannot be used as an Internationalized Domain Name and the a pplication		* domain name cannot be used as an Internationalized Domain Name and the a pplication
	* should have methods defined to deal with the failure.		* should have methods defined to deal with the failure.
	*		*
	* <b>Note:</b> IDNA RFC specifies that a conformant application should div ide a domain name		* <b>Note:</b> IDNA RFC specifies that a conformant application should div ide a domain name
	* into separate labels, decide whether to apply allowUnassigned and useSTD 3ASCIIRules on each,		* into separate labels, decide whether to apply allowUnassigned and useSTD 3ASCIIRules on each,
	* and then convert. This function does not offer that level of granularity . The options once		* and then convert. This function does not offer that level of granularity . The options once
	* set will apply to all labels in the domain name		* set will apply to all labels in the domain name
	*		*
	skipping to change at line 220		skipping to change at line 642
	* @stable ICU 2.6		* @stable ICU 2.6
	*/		*/
	U_STABLE int32_t U_EXPORT2		U_STABLE int32_t U_EXPORT2
	uidna_IDNToASCII( const UChar* src, int32_t srcLength,		uidna_IDNToASCII( const UChar* src, int32_t srcLength,
	UChar* dest, int32_t destCapacity,		UChar* dest, int32_t destCapacity,
	int32_t options,		int32_t options,
	UParseError* parseError,		UParseError* parseError,
	UErrorCode* status);		UErrorCode* status);
	/**		/**
	* Convenience function that implements the IDNToUnicode operation as defin ed in the IDNA RFC.		* IDNA2003: Convenience function that implements the IDNToUnicode operatio n as defined in the IDNA RFC.
	* This operation is done on complete domain names, e.g: "www.example.com".		* This operation is done on complete domain names, e.g: "www.example.com".
	*		*
	* <b>Note:</b> IDNA RFC specifies that a conformant application should div ide a domain name		* <b>Note:</b> IDNA RFC specifies that a conformant application should div ide a domain name
	* into separate labels, decide whether to apply allowUnassigned and useSTD 3ASCIIRules on each,		* into separate labels, decide whether to apply allowUnassigned and useSTD 3ASCIIRules on each,
	* and then convert. This function does not offer that level of granularity . The options once		* and then convert. This function does not offer that level of granularity . The options once
	* set will apply to all labels in the domain name		* set will apply to all labels in the domain name
	*		*
	* @param src Input UChar array containing IDN in ASCII (ACE encoded) form.		* @param src Input UChar array containing IDN in ASCII (ACE encoded) form.
	* @param srcLength Number of UChars in src, or -1 if NUL-terminate d.		* @param srcLength Number of UChars in src, or -1 if NUL-terminate d.
	* @param dest Output UChar array containing Unicode equivalent of so urce IDN.		* @param dest Output UChar array containing Unicode equivalent of so urce IDN.
	skipping to change at line 267		skipping to change at line 689
	* @stable ICU 2.6		* @stable ICU 2.6
	*/		*/
	U_STABLE int32_t U_EXPORT2		U_STABLE int32_t U_EXPORT2
	uidna_IDNToUnicode( const UChar* src, int32_t srcLength,		uidna_IDNToUnicode( const UChar* src, int32_t srcLength,
	UChar* dest, int32_t destCapacity,		UChar* dest, int32_t destCapacity,
	int32_t options,		int32_t options,
	UParseError* parseError,		UParseError* parseError,
	UErrorCode* status);		UErrorCode* status);
	/**		/**
	* Compare two IDN strings for equivalence.		* IDNA2003: Compare two IDN strings for equivalence.
	* This function splits the domain names into labels and compares them.		* This function splits the domain names into labels and compares them.
	* According to IDN RFC, whenever two labels are compared, they are		* According to IDN RFC, whenever two labels are compared, they are
	* considered equal if and only if their ASCII forms (obtained by		* considered equal if and only if their ASCII forms (obtained by
	* applying toASCII) match using an case-insensitive ASCII comparison.		* applying toASCII) match using an case-insensitive ASCII comparison.
	* Two domain names are considered a match if and only if all labels		* Two domain names are considered a match if and only if all labels
	* match regardless of whether label separators match.		* match regardless of whether label separators match.
	*		*
	* @param s1 First source string.		* @param s1 First source string.
	* @param length1 Length of first source string, or -1 if NUL-ter minated.		* @param length1 Length of first source string, or -1 if NUL-ter minated.
	*		*
End of changes. 21 change blocks.
	45 lines changed or deleted		495 lines changed or added

	uintrnal.h		uintrnal.h
	skipping to change at line 148		skipping to change at line 148
	# define utext_caseCompare utext_caseCompare_INTERNAL_API_DO_NOT_USE		# define utext_caseCompare utext_caseCompare_INTERNAL_API_DO_NOT_USE
	# define utext_caseCompareNativeLimit utext_caseCompareNativeLimit_I NTERNAL_API_DO_NOT_USE		# define utext_caseCompareNativeLimit utext_caseCompareNativeLimit_I NTERNAL_API_DO_NOT_USE
	# define utext_compare utext_compare_INTERNAL_API_DO_NOT_USE		# define utext_compare utext_compare_INTERNAL_API_DO_NOT_USE
	# define utext_compareNativeLimit utext_compareNativeLimit_INTERNAL_ API_DO_NOT_USE		# define utext_compareNativeLimit utext_compareNativeLimit_INTERNAL_ API_DO_NOT_USE
	# define utf8_appendCharSafeBody utf8_appendCharSafeBody_INTERNAL_AP I_DO_NOT_USE		# define utf8_appendCharSafeBody utf8_appendCharSafeBody_INTERNAL_AP I_DO_NOT_USE
	# define utf8_back1SafeBody utf8_back1SafeBody_INTERNAL_API_DO_NOT_U SE		# define utf8_back1SafeBody utf8_back1SafeBody_INTERNAL_API_DO_NOT_U SE
	# define utf8_countTrailBytes utf8_countTrailBytes_INTERNAL_API_DO_N OT_USE		# define utf8_countTrailBytes utf8_countTrailBytes_INTERNAL_API_DO_N OT_USE
	# define utf8_nextCharSafeBody utf8_nextCharSafeBody_INTERNAL_API_DO _NOT_USE		# define utf8_nextCharSafeBody utf8_nextCharSafeBody_INTERNAL_API_DO _NOT_USE
	# define utf8_prevCharSafeBody utf8_prevCharSafeBody_INTERNAL_API_DO _NOT_USE		# define utf8_prevCharSafeBody utf8_prevCharSafeBody_INTERNAL_API_DO _NOT_USE
	# else		# else
	# define RegexPatternDump_4_4 RegexPatternDump_INTERNAL_API_DO_NOT_U		# define RegexPatternDump_4_5 RegexPatternDump_INTERNAL_API_DO_NOT_U
	SE		SE
	# define bms_close_4_4 bms_close_INTERNAL_API_DO_NOT_USE		# define bms_close_4_5 bms_close_INTERNAL_API_DO_NOT_USE
	# define bms_empty_4_4 bms_empty_INTERNAL_API_DO_NOT_USE		# define bms_empty_4_5 bms_empty_INTERNAL_API_DO_NOT_USE
	# define bms_getData_4_4 bms_getData_INTERNAL_API_DO_NOT_USE		# define bms_getData_4_5 bms_getData_INTERNAL_API_DO_NOT_USE
	# define bms_open_4_4 bms_open_INTERNAL_API_DO_NOT_USE		# define bms_open_4_5 bms_open_INTERNAL_API_DO_NOT_USE
	# define bms_search_4_4 bms_search_INTERNAL_API_DO_NOT_USE		# define bms_search_4_5 bms_search_INTERNAL_API_DO_NOT_USE
	# define bms_setTargetString_4_4 bms_setTargetString_INTERNAL_API_DO		# define bms_setTargetString_4_5 bms_setTargetString_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define pl_addFontRun_4_4 pl_addFontRun_INTERNAL_API_DO_NOT_USE		# define pl_addFontRun_4_5 pl_addFontRun_INTERNAL_API_DO_NOT_USE
	# define pl_addLocaleRun_4_4 pl_addLocaleRun_INTERNAL_API_DO_NOT_USE		# define pl_addLocaleRun_4_5 pl_addLocaleRun_INTERNAL_API_DO_NOT_USE
	# define pl_addValueRun_4_4 pl_addValueRun_INTERNAL_API_DO_NOT_USE		# define pl_addValueRun_4_5 pl_addValueRun_INTERNAL_API_DO_NOT_USE
	# define pl_closeFontRuns_4_4 pl_closeFontRuns_INTERNAL_API_DO_NOT_U		# define pl_closeFontRuns_4_5 pl_closeFontRuns_INTERNAL_API_DO_NOT_U
	SE		SE
	# define pl_closeLine_4_4 pl_closeLine_INTERNAL_API_DO_NOT_USE		# define pl_closeLine_4_5 pl_closeLine_INTERNAL_API_DO_NOT_USE
	# define pl_closeLocaleRuns_4_4 pl_closeLocaleRuns_INTERNAL_API_DO_N		# define pl_closeLocaleRuns_4_5 pl_closeLocaleRuns_INTERNAL_API_DO_N
	OT_USE		OT_USE
	# define pl_closeValueRuns_4_4 pl_closeValueRuns_INTERNAL_API_DO_NOT		# define pl_closeValueRuns_4_5 pl_closeValueRuns_INTERNAL_API_DO_NOT
	_USE		_USE
	# define pl_close_4_4 pl_close_INTERNAL_API_DO_NOT_USE		# define pl_close_4_5 pl_close_INTERNAL_API_DO_NOT_USE
	# define pl_countLineRuns_4_4 pl_countLineRuns_INTERNAL_API_DO_NOT_U		# define pl_countLineRuns_4_5 pl_countLineRuns_INTERNAL_API_DO_NOT_U
	SE		SE
	# define pl_create_4_4 pl_create_INTERNAL_API_DO_NOT_USE		# define pl_create_4_5 pl_create_INTERNAL_API_DO_NOT_USE
	# define pl_getAscent_4_4 pl_getAscent_INTERNAL_API_DO_NOT_USE		# define pl_getAscent_4_5 pl_getAscent_INTERNAL_API_DO_NOT_USE
	# define pl_getDescent_4_4 pl_getDescent_INTERNAL_API_DO_NOT_USE		# define pl_getDescent_4_5 pl_getDescent_INTERNAL_API_DO_NOT_USE
	# define pl_getFontRunCount_4_4 pl_getFontRunCount_INTERNAL_API_DO_N		# define pl_getFontRunCount_4_5 pl_getFontRunCount_INTERNAL_API_DO_N
	OT_USE		OT_USE
	# define pl_getFontRunFont_4_4 pl_getFontRunFont_INTERNAL_API_DO_NOT		# define pl_getFontRunFont_4_5 pl_getFontRunFont_INTERNAL_API_DO_NOT
	_USE		_USE
	# define pl_getFontRunLastLimit_4_4 pl_getFontRunLastLimit_INTERNAL_		# define pl_getFontRunLastLimit_4_5 pl_getFontRunLastLimit_INTERNAL_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define pl_getFontRunLimit_4_4 pl_getFontRunLimit_INTERNAL_API_DO_N		# define pl_getFontRunLimit_4_5 pl_getFontRunLimit_INTERNAL_API_DO_N
	OT_USE		OT_USE
	# define pl_getLeading_4_4 pl_getLeading_INTERNAL_API_DO_NOT_USE		# define pl_getLeading_4_5 pl_getLeading_INTERNAL_API_DO_NOT_USE
	# define pl_getLineAscent_4_4 pl_getLineAscent_INTERNAL_API_DO_NOT_U		# define pl_getLineAscent_4_5 pl_getLineAscent_INTERNAL_API_DO_NOT_U
	SE		SE
	# define pl_getLineDescent_4_4 pl_getLineDescent_INTERNAL_API_DO_NOT		# define pl_getLineDescent_4_5 pl_getLineDescent_INTERNAL_API_DO_NOT
	_USE		_USE
	# define pl_getLineLeading_4_4 pl_getLineLeading_INTERNAL_API_DO_NOT		# define pl_getLineLeading_4_5 pl_getLineLeading_INTERNAL_API_DO_NOT
	_USE		_USE
	# define pl_getLineVisualRun_4_4 pl_getLineVisualRun_INTERNAL_API_DO		# define pl_getLineVisualRun_4_5 pl_getLineVisualRun_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define pl_getLineWidth_4_4 pl_getLineWidth_INTERNAL_API_DO_NOT_USE		# define pl_getLineWidth_4_5 pl_getLineWidth_INTERNAL_API_DO_NOT_USE
	# define pl_getLocaleRunCount_4_4 pl_getLocaleRunCount_INTERNAL_API_		# define pl_getLocaleRunCount_4_5 pl_getLocaleRunCount_INTERNAL_API_
	DO_NOT_USE		DO_NOT_USE
	# define pl_getLocaleRunLastLimit_4_4 pl_getLocaleRunLastLimit_INTER		# define pl_getLocaleRunLastLimit_4_5 pl_getLocaleRunLastLimit_INTER
	NAL_API_DO_NOT_USE		NAL_API_DO_NOT_USE
	# define pl_getLocaleRunLimit_4_4 pl_getLocaleRunLimit_INTERNAL_API_		# define pl_getLocaleRunLimit_4_5 pl_getLocaleRunLimit_INTERNAL_API_
	DO_NOT_USE		DO_NOT_USE
	# define pl_getLocaleRunLocale_4_4 pl_getLocaleRunLocale_INTERNAL_AP		# define pl_getLocaleRunLocale_4_5 pl_getLocaleRunLocale_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define pl_getParagraphLevel_4_4 pl_getParagraphLevel_INTERNAL_API_		# define pl_getParagraphLevel_4_5 pl_getParagraphLevel_INTERNAL_API_
	DO_NOT_USE		DO_NOT_USE
	# define pl_getTextDirection_4_4 pl_getTextDirection_INTERNAL_API_DO		# define pl_getTextDirection_4_5 pl_getTextDirection_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define pl_getValueRunCount_4_4 pl_getValueRunCount_INTERNAL_API_DO		# define pl_getValueRunCount_4_5 pl_getValueRunCount_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define pl_getValueRunLastLimit_4_4 pl_getValueRunLastLimit_INTERNA		# define pl_getValueRunLastLimit_4_5 pl_getValueRunLastLimit_INTERNA
	L_API_DO_NOT_USE		L_API_DO_NOT_USE
	# define pl_getValueRunLimit_4_4 pl_getValueRunLimit_INTERNAL_API_DO		# define pl_getValueRunLimit_4_5 pl_getValueRunLimit_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define pl_getValueRunValue_4_4 pl_getValueRunValue_INTERNAL_API_DO		# define pl_getValueRunValue_4_5 pl_getValueRunValue_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define pl_getVisualRunAscent_4_4 pl_getVisualRunAscent_INTERNAL_AP		# define pl_getVisualRunAscent_4_5 pl_getVisualRunAscent_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define pl_getVisualRunDescent_4_4 pl_getVisualRunDescent_INTERNAL_		# define pl_getVisualRunDescent_4_5 pl_getVisualRunDescent_INTERNAL_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define pl_getVisualRunDirection_4_4 pl_getVisualRunDirection_INTER		# define pl_getVisualRunDirection_4_5 pl_getVisualRunDirection_INTER
	NAL_API_DO_NOT_USE		NAL_API_DO_NOT_USE
	# define pl_getVisualRunFont_4_4 pl_getVisualRunFont_INTERNAL_API_DO		# define pl_getVisualRunFont_4_5 pl_getVisualRunFont_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define pl_getVisualRunGlyphCount_4_4 pl_getVisualRunGlyphCount_INT		# define pl_getVisualRunGlyphCount_4_5 pl_getVisualRunGlyphCount_INT
	ERNAL_API_DO_NOT_USE		ERNAL_API_DO_NOT_USE
	# define pl_getVisualRunGlyphToCharMap_4_4 pl_getVisualRunGlyphToCha		# define pl_getVisualRunGlyphToCharMap_4_5 pl_getVisualRunGlyphToCha
	rMap_INTERNAL_API_DO_NOT_USE		rMap_INTERNAL_API_DO_NOT_USE
	# define pl_getVisualRunGlyphs_4_4 pl_getVisualRunGlyphs_INTERNAL_AP		# define pl_getVisualRunGlyphs_4_5 pl_getVisualRunGlyphs_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define pl_getVisualRunLeading_4_4 pl_getVisualRunLeading_INTERNAL_		# define pl_getVisualRunLeading_4_5 pl_getVisualRunLeading_INTERNAL_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define pl_getVisualRunPositions_4_4 pl_getVisualRunPositions_INTER		# define pl_getVisualRunPositions_4_5 pl_getVisualRunPositions_INTER
	NAL_API_DO_NOT_USE		NAL_API_DO_NOT_USE
	# define pl_isComplex_4_4 pl_isComplex_INTERNAL_API_DO_NOT_USE		# define pl_isComplex_4_5 pl_isComplex_INTERNAL_API_DO_NOT_USE
	# define pl_line_4_4 pl_line_INTERNAL_API_DO_NOT_USE		# define pl_line_4_5 pl_line_INTERNAL_API_DO_NOT_USE
	# define pl_nextLine_4_4 pl_nextLine_INTERNAL_API_DO_NOT_USE		# define pl_nextLine_4_5 pl_nextLine_INTERNAL_API_DO_NOT_USE
	# define pl_openEmptyFontRuns_4_4 pl_openEmptyFontRuns_INTERNAL_API_		# define pl_openEmptyFontRuns_4_5 pl_openEmptyFontRuns_INTERNAL_API_
	DO_NOT_USE		DO_NOT_USE
	# define pl_openEmptyLocaleRuns_4_4 pl_openEmptyLocaleRuns_INTERNAL_		# define pl_openEmptyLocaleRuns_4_5 pl_openEmptyLocaleRuns_INTERNAL_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define pl_openEmptyValueRuns_4_4 pl_openEmptyValueRuns_INTERNAL_AP		# define pl_openEmptyValueRuns_4_5 pl_openEmptyValueRuns_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define pl_openFontRuns_4_4 pl_openFontRuns_INTERNAL_API_DO_NOT_USE		# define pl_openFontRuns_4_5 pl_openFontRuns_INTERNAL_API_DO_NOT_USE
	# define pl_openLocaleRuns_4_4 pl_openLocaleRuns_INTERNAL_API_DO_NOT		# define pl_openLocaleRuns_4_5 pl_openLocaleRuns_INTERNAL_API_DO_NOT
	_USE		_USE
	# define pl_openValueRuns_4_4 pl_openValueRuns_INTERNAL_API_DO_NOT_U		# define pl_openValueRuns_4_5 pl_openValueRuns_INTERNAL_API_DO_NOT_U
	SE		SE
	# define pl_paragraph_4_4 pl_paragraph_INTERNAL_API_DO_NOT_USE		# define pl_paragraph_4_5 pl_paragraph_INTERNAL_API_DO_NOT_USE
	# define pl_reflow_4_4 pl_reflow_INTERNAL_API_DO_NOT_USE		# define pl_reflow_4_5 pl_reflow_INTERNAL_API_DO_NOT_USE
	# define pl_resetFontRuns_4_4 pl_resetFontRuns_INTERNAL_API_DO_NOT_U		# define pl_resetFontRuns_4_5 pl_resetFontRuns_INTERNAL_API_DO_NOT_U
	SE		SE
	# define pl_resetLocaleRuns_4_4 pl_resetLocaleRuns_INTERNAL_API_DO_N		# define pl_resetLocaleRuns_4_5 pl_resetLocaleRuns_INTERNAL_API_DO_N
	OT_USE		OT_USE
	# define pl_resetValueRuns_4_4 pl_resetValueRuns_INTERNAL_API_DO_NOT		# define pl_resetValueRuns_4_5 pl_resetValueRuns_INTERNAL_API_DO_NOT
	_USE		_USE
	# define pl_visualRun_4_4 pl_visualRun_INTERNAL_API_DO_NOT_USE		# define pl_visualRun_4_5 pl_visualRun_INTERNAL_API_DO_NOT_USE
	# define ucd_close_4_4 ucd_close_INTERNAL_API_DO_NOT_USE		# define ucd_close_4_5 ucd_close_INTERNAL_API_DO_NOT_USE
	# define ucd_flushCache_4_4 ucd_flushCache_INTERNAL_API_DO_NOT_USE		# define ucd_flushCache_4_5 ucd_flushCache_INTERNAL_API_DO_NOT_USE
	# define ucd_freeCache_4_4 ucd_freeCache_INTERNAL_API_DO_NOT_USE		# define ucd_freeCache_4_5 ucd_freeCache_INTERNAL_API_DO_NOT_USE
	# define ucd_getCollator_4_4 ucd_getCollator_INTERNAL_API_DO_NOT_USE		# define ucd_getCollator_4_5 ucd_getCollator_INTERNAL_API_DO_NOT_USE
	# define ucd_open_4_4 ucd_open_INTERNAL_API_DO_NOT_USE		# define ucd_open_4_5 ucd_open_INTERNAL_API_DO_NOT_USE
	# define ucol_equals_4_4 ucol_equals_INTERNAL_API_DO_NOT_USE		# define ucol_equals_4_5 ucol_equals_INTERNAL_API_DO_NOT_USE
	# define ucol_forceHanImplicit_4_4 ucol_forceHanImplicit_INTERNAL_AP		# define ucol_forceHanImplicit_4_5 ucol_forceHanImplicit_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define ucol_forgetUCA_4_4 ucol_forgetUCA_INTERNAL_API_DO_NOT_USE		# define ucol_forgetUCA_4_5 ucol_forgetUCA_INTERNAL_API_DO_NOT_USE
	# define ucol_getAttributeOrDefault_4_4 ucol_getAttributeOrDefault_I		# define ucol_getAttributeOrDefault_4_5 ucol_getAttributeOrDefault_I
	NTERNAL_API_DO_NOT_USE		NTERNAL_API_DO_NOT_USE
	# define ucol_getUnsafeSet_4_4 ucol_getUnsafeSet_INTERNAL_API_DO_NOT		# define ucol_getUnsafeSet_4_5 ucol_getUnsafeSet_INTERNAL_API_DO_NOT
	_USE		_USE
	# define ucol_nextProcessed_4_4 ucol_nextProcessed_INTERNAL_API_DO_N		# define ucol_nextProcessed_4_5 ucol_nextProcessed_INTERNAL_API_DO_N
	OT_USE		OT_USE
	# define ucol_prepareShortStringOpen_4_4 ucol_prepareShortStringOpen		# define ucol_prepareShortStringOpen_4_5 ucol_prepareShortStringOpen
	_INTERNAL_API_DO_NOT_USE		_INTERNAL_API_DO_NOT_USE
	# define ucol_previousProcessed_4_4 ucol_previousProcessed_INTERNAL_		# define ucol_previousProcessed_4_5 ucol_previousProcessed_INTERNAL_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define udat_applyPatternRelative_4_4 udat_applyPatternRelative_INT		# define udat_applyPatternRelative_4_5 udat_applyPatternRelative_INT
	ERNAL_API_DO_NOT_USE		ERNAL_API_DO_NOT_USE
	# define udat_toPatternRelativeDate_4_4 udat_toPatternRelativeDate_I		# define udat_toPatternRelativeDate_4_5 udat_toPatternRelativeDate_I
	NTERNAL_API_DO_NOT_USE		NTERNAL_API_DO_NOT_USE
	# define udat_toPatternRelativeTime_4_4 udat_toPatternRelativeTime_I		# define udat_toPatternRelativeTime_4_5 udat_toPatternRelativeTime_I
	NTERNAL_API_DO_NOT_USE		NTERNAL_API_DO_NOT_USE
	# define uplug_getConfiguration_4_4 uplug_getConfiguration_INTERNAL_		# define uplug_getConfiguration_4_5 uplug_getConfiguration_INTERNAL_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define uplug_getContext_4_4 uplug_getContext_INTERNAL_API_DO_NOT_U		# define uplug_getContext_4_5 uplug_getContext_INTERNAL_API_DO_NOT_U
	SE		SE
	# define uplug_getCurrentLevel_4_4 uplug_getCurrentLevel_INTERNAL_AP		# define uplug_getCurrentLevel_4_5 uplug_getCurrentLevel_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define uplug_getLibraryName_4_4 uplug_getLibraryName_INTERNAL_API_		# define uplug_getLibraryName_4_5 uplug_getLibraryName_INTERNAL_API_
	DO_NOT_USE		DO_NOT_USE
	# define uplug_getLibrary_4_4 uplug_getLibrary_INTERNAL_API_DO_NOT_U		# define uplug_getLibrary_4_5 uplug_getLibrary_INTERNAL_API_DO_NOT_U
	SE		SE
	# define uplug_getPlugLevel_4_4 uplug_getPlugLevel_INTERNAL_API_DO_N		# define uplug_getPlugLevel_4_5 uplug_getPlugLevel_INTERNAL_API_DO_N
	OT_USE		OT_USE
	# define uplug_getPlugLoadStatus_4_4 uplug_getPlugLoadStatus_INTERNA		# define uplug_getPlugLoadStatus_4_5 uplug_getPlugLoadStatus_INTERNA
	L_API_DO_NOT_USE		L_API_DO_NOT_USE
	# define uplug_getPlugName_4_4 uplug_getPlugName_INTERNAL_API_DO_NOT		# define uplug_getPlugName_4_5 uplug_getPlugName_INTERNAL_API_DO_NOT
	_USE		_USE
	# define uplug_getSymbolName_4_4 uplug_getSymbolName_INTERNAL_API_DO		# define uplug_getSymbolName_4_5 uplug_getSymbolName_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define uplug_loadPlugFromEntrypoint_4_4 uplug_loadPlugFromEntrypoi		# define uplug_loadPlugFromEntrypoint_4_5 uplug_loadPlugFromEntrypoi
	nt_INTERNAL_API_DO_NOT_USE		nt_INTERNAL_API_DO_NOT_USE
	# define uplug_loadPlugFromLibrary_4_4 uplug_loadPlugFromLibrary_INT		# define uplug_loadPlugFromLibrary_4_5 uplug_loadPlugFromLibrary_INT
	ERNAL_API_DO_NOT_USE		ERNAL_API_DO_NOT_USE
	# define uplug_nextPlug_4_4 uplug_nextPlug_INTERNAL_API_DO_NOT_USE		# define uplug_nextPlug_4_5 uplug_nextPlug_INTERNAL_API_DO_NOT_USE
	# define uplug_removePlug_4_4 uplug_removePlug_INTERNAL_API_DO_NOT_U		# define uplug_removePlug_4_5 uplug_removePlug_INTERNAL_API_DO_NOT_U
	SE		SE
	# define uplug_setContext_4_4 uplug_setContext_INTERNAL_API_DO_NOT_U		# define uplug_setContext_4_5 uplug_setContext_INTERNAL_API_DO_NOT_U
	SE		SE
	# define uplug_setPlugLevel_4_4 uplug_setPlugLevel_INTERNAL_API_DO_N		# define uplug_setPlugLevel_4_5 uplug_setPlugLevel_INTERNAL_API_DO_N
	OT_USE		OT_USE
	# define uplug_setPlugName_4_4 uplug_setPlugName_INTERNAL_API_DO_NOT		# define uplug_setPlugName_4_5 uplug_setPlugName_INTERNAL_API_DO_NOT
	_USE		_USE
	# define uplug_setPlugNoUnload_4_4 uplug_setPlugNoUnload_INTERNAL_AP		# define uplug_setPlugNoUnload_4_5 uplug_setPlugNoUnload_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define uprv_getDefaultCodepage_4_4 uprv_getDefaultCodepage_INTERNA		# define uprv_getDefaultCodepage_4_5 uprv_getDefaultCodepage_INTERNA
	L_API_DO_NOT_USE		L_API_DO_NOT_USE
	# define uprv_getDefaultLocaleID_4_4 uprv_getDefaultLocaleID_INTERNA		# define uprv_getDefaultLocaleID_4_5 uprv_getDefaultLocaleID_INTERNA
	L_API_DO_NOT_USE		L_API_DO_NOT_USE
	# define uregex_appendReplacementUText_4_4 uregex_appendReplacementU		# define uregex_appendReplacementUText_4_5 uregex_appendReplacementU
	Text_INTERNAL_API_DO_NOT_USE		Text_INTERNAL_API_DO_NOT_USE
	# define uregex_appendTailUText_4_4 uregex_appendTailUText_INTERNAL_		# define uregex_appendTailUText_4_5 uregex_appendTailUText_INTERNAL_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define uregex_getUText_4_4 uregex_getUText_INTERNAL_API_DO_NOT_USE		# define uregex_getUText_4_5 uregex_getUText_INTERNAL_API_DO_NOT_USE
	# define uregex_groupUText_4_4 uregex_groupUText_INTERNAL_API_DO_NOT		# define uregex_groupUText_4_5 uregex_groupUText_INTERNAL_API_DO_NOT
	_USE		_USE
	# define uregex_openUText_4_4 uregex_openUText_INTERNAL_API_DO_NOT_U		# define uregex_openUText_4_5 uregex_openUText_INTERNAL_API_DO_NOT_U
	SE		SE
	# define uregex_patternUText_4_4 uregex_patternUText_INTERNAL_API_DO		# define uregex_patternUText_4_5 uregex_patternUText_INTERNAL_API_DO
	_NOT_USE		_NOT_USE
	# define uregex_replaceAllUText_4_4 uregex_replaceAllUText_INTERNAL_		# define uregex_replaceAllUText_4_5 uregex_replaceAllUText_INTERNAL_
	API_DO_NOT_USE		API_DO_NOT_USE
	# define uregex_replaceFirstUText_4_4 uregex_replaceFirstUText_INTER		# define uregex_replaceFirstUText_4_5 uregex_replaceFirstUText_INTER
	NAL_API_DO_NOT_USE		NAL_API_DO_NOT_USE
	# define uregex_setUText_4_4 uregex_setUText_INTERNAL_API_DO_NOT_USE		# define uregex_setUText_4_5 uregex_setUText_INTERNAL_API_DO_NOT_USE
	# define uregex_splitUText_4_4 uregex_splitUText_INTERNAL_API_DO_NOT		# define uregex_splitUText_4_5 uregex_splitUText_INTERNAL_API_DO_NOT
	_USE		_USE
	# define ures_openFillIn_4_4 ures_openFillIn_INTERNAL_API_DO_NOT_USE		# define ures_openFillIn_4_5 ures_openFillIn_INTERNAL_API_DO_NOT_USE
	# define usearch_searchBackwards_4_4 usearch_searchBackwards_INTERNA		# define usearch_searchBackwards_4_5 usearch_searchBackwards_INTERNA
	L_API_DO_NOT_USE		L_API_DO_NOT_USE
	# define usearch_search_4_4 usearch_search_INTERNAL_API_DO_NOT_USE		# define usearch_search_4_5 usearch_search_INTERNAL_API_DO_NOT_USE
	# define utext_caseCompareNativeLimit_4_4 utext_caseCompareNativeLim		# define utext_caseCompareNativeLimit_4_5 utext_caseCompareNativeLim
	it_INTERNAL_API_DO_NOT_USE		it_INTERNAL_API_DO_NOT_USE
	# define utext_caseCompare_4_4 utext_caseCompare_INTERNAL_API_DO_NOT		# define utext_caseCompare_4_5 utext_caseCompare_INTERNAL_API_DO_NOT
	_USE		_USE
	# define utext_compareNativeLimit_4_4 utext_compareNativeLimit_INTER		# define utext_compareNativeLimit_4_5 utext_compareNativeLimit_INTER
	NAL_API_DO_NOT_USE		NAL_API_DO_NOT_USE
	# define utext_compare_4_4 utext_compare_INTERNAL_API_DO_NOT_USE		# define utext_compare_4_5 utext_compare_INTERNAL_API_DO_NOT_USE
	# define utf8_appendCharSafeBody_4_4 utf8_appendCharSafeBody_INTERNA		# define utf8_appendCharSafeBody_4_5 utf8_appendCharSafeBody_INTERNA
	L_API_DO_NOT_USE		L_API_DO_NOT_USE
	# define utf8_back1SafeBody_4_4 utf8_back1SafeBody_INTERNAL_API_DO_N		# define utf8_back1SafeBody_4_5 utf8_back1SafeBody_INTERNAL_API_DO_N
	OT_USE		OT_USE
	# define utf8_countTrailBytes_4_4 utf8_countTrailBytes_INTERNAL_API_		# define utf8_countTrailBytes_4_5 utf8_countTrailBytes_INTERNAL_API_
	DO_NOT_USE		DO_NOT_USE
	# define utf8_nextCharSafeBody_4_4 utf8_nextCharSafeBody_INTERNAL_AP		# define utf8_nextCharSafeBody_4_5 utf8_nextCharSafeBody_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# define utf8_prevCharSafeBody_4_4 utf8_prevCharSafeBody_INTERNAL_AP		# define utf8_prevCharSafeBody_4_5 utf8_prevCharSafeBody_INTERNAL_AP
	I_DO_NOT_USE		I_DO_NOT_USE
	# endif /* U_DISABLE_RENAMING */		# endif /* U_DISABLE_RENAMING */
	#endif /* U_HIDE_INTERNAL_API */		#endif /* U_HIDE_INTERNAL_API */
	#endif /* UINTRNAL_H */		#endif /* UINTRNAL_H */
End of changes. 1 change blocks.
	205 lines changed or deleted		205 lines changed or added

	umachine.h		umachine.h
	skipping to change at line 45		skipping to change at line 45
	* the UTF-handling macros made this unmaintainable.		* the UTF-handling macros made this unmaintainable.
	*		*
	*/		*/
	/*========================================================================= =*/		/*========================================================================= =*/
	/* Include platform-dependent definitions */		/* Include platform-dependent definitions */
	/* which are contained in the platform-specific file platform.h */		/* which are contained in the platform-specific file platform.h */
	/*========================================================================= =*/		/*========================================================================= =*/
	#if defined(U_PALMOS)		#if defined(U_PALMOS)
	# include "unicode/ppalmos.h"		# include "unicode/ppalmos.h"
	#elif defined(WIN32) || defined(_WIN32) || defined(WIN64) || defined(_WIN64 )		#elif !defined(__MINGW32__) && (defined(WIN32) || defined(_WIN32) || define d(WIN64) || defined(_WIN64))
	#ifdef CYGWINMSVC		#ifdef CYGWINMSVC
	# include "unicode/platform.h"		# include "unicode/platform.h"
	#endif		#endif
	# include "unicode/pwin32.h"		# include "unicode/pwin32.h"
	#else		#else
	# include "unicode/ptypes.h" /* platform.h is included in ptypes.h */		# include "unicode/ptypes.h" /* platform.h is included in ptypes.h */
	#endif		#endif
	/*		/*
	* ANSI C headers:		* ANSI C headers:
End of changes. 1 change blocks.
	1 lines changed or deleted		1 lines changed or added

	unifilt.h		unifilt.h
	/*		/*
	**********************************************************************		**********************************************************************
	* Copyright (C) 1999-2006, International Business Machines Corporation and others.		* Copyright (C) 1999-2010, International Business Machines Corporation and others.
	* All Rights Reserved.		* All Rights Reserved.
	**********************************************************************		**********************************************************************
	* Date Name Description		* Date Name Description
	* 11/17/99 aliu Creation.		* 11/17/99 aliu Creation.
	**********************************************************************		**********************************************************************
	*/		*/
	#ifndef UNIFILT_H		#ifndef UNIFILT_H
	#define UNIFILT_H		#define UNIFILT_H
	#include "unicode/unifunct.h"		#include "unicode/unifunct.h"
	skipping to change at line 100		skipping to change at line 100
	int32_t limit,		int32_t limit,
	UBool incremental);		UBool incremental);
	/**		/**
	* UnicodeFunctor API. Nothing to do.		* UnicodeFunctor API. Nothing to do.
	* @stable ICU 2.4		* @stable ICU 2.4
	*/		*/
	virtual void setData(const TransliterationRuleData*);		virtual void setData(const TransliterationRuleData*);
	/**		/**
	* ICU "poor man's RTTI", returns a UClassID for the actual class.
	*
	* @stable ICU 2.2
	*/
	virtual UClassID getDynamicClassID() const = 0;
	/**
	* ICU "poor man's RTTI", returns a UClassID for this class.		* ICU "poor man's RTTI", returns a UClassID for this class.
	*		*
	* @stable ICU 2.2		* @stable ICU 2.2
	*/		*/
	static UClassID U_EXPORT2 getStaticClassID();		static UClassID U_EXPORT2 getStaticClassID();
	protected:		protected:
	/*		/*
	* Since this class has pure virtual functions,		* Since this class has pure virtual functions,
End of changes. 2 change blocks.
	8 lines changed or deleted		1 lines changed or added

	unistr.h		unistr.h
	skipping to change at line 1601		skipping to change at line 1601
	*/		*/
	inline UnicodeString tempSubStringBetween(int32_t start, int32_t limit=IN T32_MAX) const;		inline UnicodeString tempSubStringBetween(int32_t start, int32_t limit=IN T32_MAX) const;
	/**		/**
	* Convert the UnicodeString to UTF-8 and write the result		* Convert the UnicodeString to UTF-8 and write the result
	* to a ByteSink. This is called by toUTF8String().		* to a ByteSink. This is called by toUTF8String().
	* Unpaired surrogates are replaced with U+FFFD.		* Unpaired surrogates are replaced with U+FFFD.
	* Calls u_strToUTF8WithSub().		* Calls u_strToUTF8WithSub().
	*		*
	* @param sink A ByteSink to which the UTF-8 version of the string is wri tten.		* @param sink A ByteSink to which the UTF-8 version of the string is wri tten.
			* sink.Flush() is called at the end.
	* @stable ICU 4.2		* @stable ICU 4.2
	* @see toUTF8String		* @see toUTF8String
	*/		*/
	void toUTF8(ByteSink &sink) const;		void toUTF8(ByteSink &sink) const;
	#if U_HAVE_STD_STRING		#if U_HAVE_STD_STRING
	/**		/**
	* Convert the UnicodeString to UTF-8 and append the result		* Convert the UnicodeString to UTF-8 and append the result
	* to a standard string.		* to a standard string.
End of changes. 1 change blocks.
	0 lines changed or deleted		1 lines changed or added

	unorm2.h		unorm2.h
	skipping to change at line 154		skipping to change at line 154
	const char *name,		const char *name,
	UNormalization2Mode mode,		UNormalization2Mode mode,
	UErrorCode *pErrorCode);		UErrorCode *pErrorCode);
	/**		/**
	* Constructs a filtered normalizer wrapping any UNormalizer2 instance		* Constructs a filtered normalizer wrapping any UNormalizer2 instance
	* and a filter set.		* and a filter set.
	* Both are aliased and must not be modified or deleted while this object		* Both are aliased and must not be modified or deleted while this object
	* is used.		* is used.
	* The filter set should be frozen; otherwise the performance will suffer g reatly.		* The filter set should be frozen; otherwise the performance will suffer g reatly.
	* @param norm2 wrapped Normalizer2 instance		* @param norm2 wrapped UNormalizer2 instance
	* @param filterSet USet which determines the characters to be normalized		* @param filterSet USet which determines the characters to be normalized
	* @param pErrorCode Standard ICU error code. Its input value must		* @param pErrorCode Standard ICU error code. Its input value must
	* pass the U_SUCCESS() test, or else the function return s		* pass the U_SUCCESS() test, or else the function return s
	* immediately. Check for U_FAILURE() on output or use wi th		* immediately. Check for U_FAILURE() on output or use wi th
	* function chaining. (See User Guide for details.)		* function chaining. (See User Guide for details.)
	* @return the requested UNormalizer2, if successful		* @return the requested UNormalizer2, if successful
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	U_DRAFT UNormalizer2 * U_EXPORT2		U_DRAFT UNormalizer2 * U_EXPORT2
	unorm2_openFiltered(const UNormalizer2 *norm2, const USet *filterSet, UErro rCode *pErrorCode);		unorm2_openFiltered(const UNormalizer2 *norm2, const USet *filterSet, UErro rCode *pErrorCode);
	skipping to change at line 263		skipping to change at line 263
	* @return first		* @return first
	* @draft ICU 4.4		* @draft ICU 4.4
	*/		*/
	U_DRAFT int32_t U_EXPORT2		U_DRAFT int32_t U_EXPORT2
	unorm2_append(const UNormalizer2 *norm2,		unorm2_append(const UNormalizer2 *norm2,
	UChar *first, int32_t firstLength, int32_t firstCapacity,		UChar *first, int32_t firstLength, int32_t firstCapacity,
	const UChar *second, int32_t secondLength,		const UChar *second, int32_t secondLength,
	UErrorCode *pErrorCode);		UErrorCode *pErrorCode);
	/**		/**
			* Gets the decomposition mapping of c. Equivalent to unorm2_normalize(stri
			ng(c))
			* on a UNORM2_DECOMPOSE UNormalizer2 instance, but much faster.
			* This function is independent of the mode of the UNormalizer2.
			* @param norm2 UNormalizer2 instance
			* @param c code point
			* @param decomposition String buffer which will be set to c's
			* decomposition mapping, if there is one.
			* @param capacity number of UChars that can be written to decomposition
			* @param pErrorCode Standard ICU error code. Its input value must
			* pass the U_SUCCESS() test, or else the function return
			s
			* immediately. Check for U_FAILURE() on output or use wi
			th
			* function chaining. (See User Guide for details.)
			* @return the non-negative length of c's decomposition, if there is one; o
			therwise a negative value
			* @draft ICU 4.6
			*/
			U_DRAFT int32_t U_EXPORT2
			unorm2_getDecomposition(const UNormalizer2 *norm2,
			UChar32 c, UChar *decomposition, int32_t capacity,
			UErrorCode *pErrorCode);
			/**
	* Tests if the string is normalized.		* Tests if the string is normalized.
	* Internally, in cases where the quickCheck() method would return "maybe"		* Internally, in cases where the quickCheck() method would return "maybe"
	* (which is only possible for the two COMPOSE modes) this method		* (which is only possible for the two COMPOSE modes) this method
	* resolves to "yes" or "no" to provide a definitive result,		* resolves to "yes" or "no" to provide a definitive result,
	* at the cost of doing more work in those cases.		* at the cost of doing more work in those cases.
	* @param norm2 UNormalizer2 instance		* @param norm2 UNormalizer2 instance
	* @param s input string		* @param s input string
	* @param length length of the string, or -1 if NUL-terminated		* @param length length of the string, or -1 if NUL-terminated
	* @param pErrorCode Standard ICU error code. Its input value must		* @param pErrorCode Standard ICU error code. Its input value must
	* pass the U_SUCCESS() test, or else the function return s		* pass the U_SUCCESS() test, or else the function return s
End of changes. 2 change blocks.
	1 lines changed or deleted		26 lines changed or added

	uobject.h		uobject.h
	skipping to change at line 318		skipping to change at line 318
	*		*
	* @param myClass The name of the class that needs RTTI defined.		* @param myClass The name of the class that needs RTTI defined.
	* @internal		* @internal
	*/		*/
	#define UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(myClass) \		#define UOBJECT_DEFINE_ABSTRACT_RTTI_IMPLEMENTATION(myClass) \
	UClassID U_EXPORT2 myClass::getStaticClassID() { \		UClassID U_EXPORT2 myClass::getStaticClassID() { \
	static char classID = 0; \		static char classID = 0; \
	return (UClassID)&classID; \		return (UClassID)&classID; \
	}		}
			/**
			* This is a simple macro to express that a class and its subclasses do not
			offer
			* ICU's "poor man's RTTI".
			* Beginning with ICU 4.6, ICU requires C++ compiler RTTI.
			* This does not go into the header. This should only be used in *.cpp file
			s.
			* Use this with a private getDynamicClassID() in an immediate subclass of
			UObject.
			*
			* @param myClass The name of the class that needs RTTI defined.
			* @internal
			*/
			#define UOBJECT_DEFINE_NO_RTTI_IMPLEMENTATION(myClass) \
			UClassID myClass::getDynamicClassID() const { return NULL; }
	// /**		// /**
	// * This macro adds ICU RTTI to an ICU concrete class implementation.		// * This macro adds ICU RTTI to an ICU concrete class implementation.
	// * This macro should be invoked in *.cpp files. The corresponding		// * This macro should be invoked in *.cpp files. The corresponding
	// * header should declare getDynamicClassID and getStaticClassID.		// * header should declare getDynamicClassID and getStaticClassID.
	// *		// *
	// * @param myClass The name of the class that needs RTTI defined.		// * @param myClass The name of the class that needs RTTI defined.
	// * @param myParent The name of the myClass's parent.		// * @param myParent The name of the myClass's parent.
	// * @internal		// * @internal
	// */		// */
	/*#define UOBJECT_DEFINE_RTTI_IMPLEMENTATION(myClass, myParent) \		/*#define UOBJECT_DEFINE_RTTI_IMPLEMENTATION(myClass, myParent) \
End of changes. 1 change blocks.
	0 lines changed or deleted		16 lines changed or added

	uregex.h		uregex.h
	skipping to change at line 1228		skipping to change at line 1228
	* was set when uregex_setMatchCallback() was called.		* was set when uregex_setMatchCallback() was called.
	* @param status A reference to a UErrorCode to receive any errors.		* @param status A reference to a UErrorCode to receive any errors.
	* @stable ICU 4.0		* @stable ICU 4.0
	*/		*/
	U_STABLE void U_EXPORT2		U_STABLE void U_EXPORT2
	uregex_getMatchCallback(const URegularExpression *regexp,		uregex_getMatchCallback(const URegularExpression *regexp,
	URegexMatchCallback **callback,		URegexMatchCallback **callback,
	const void **context,		const void **context,
	UErrorCode *status);		UErrorCode *status);
			/**
			* Function pointer for a regular expression find/findNext callback functio
			n.
			* When set, a callback function will be called during a find operation aft
			er each
			* attempt at a match. If the call back function returns FALSE, the find
			* operation will be terminated early.
			*
			* Note: the callback function must not call other functions on this
			* URegularExpression
			*
			* @param context context pointer. The callback function will be invoked
			* with the context specified at the time that
			* uregex_setFindProgressCallback() is called.
			* @param matchIndex the next index at which a match attempt will be attem
			pted for this
			* find operation. If this callback interrupts the search,
			this is the
			* index at which a find/findNext operation may be re-initi
			ated.
			* @return TRUE to continue the matching operation.
			* FALSE to terminate the matching operation.
			* @draft ICU 4.6
			*/
			U_CDECL_BEGIN
			typedef UBool U_CALLCONV URegexFindProgressCallback (
			const void *context,
			int64_t matchIndex);
			U_CDECL_END
			/**
			* During find operations, this callback will be invoked after each return
			from a
			* match attempt, specifying the next index at which a match operation is a
			bout to be attempted,
			* giving the application the opportunity to terminate a long-running find
			operation.
			*
			* @param regexp The compiled regular expression.
			* @param callback A pointer to the user-supplied callback function.
			* @param context User context pointer. The value supplied at the
			* time the callback function is set will be saved
			* and passed to the callback each time that it is cal
			led.
			* @param status A reference to a UErrorCode to receive any errors.
			* @draft ICU 4.6
			*/
			U_DRAFT void U_EXPORT2
			uregex_setFindProgressCallback(URegularExpression *regexp,
			URegexFindProgressCallback *callback,
			const void *context,
			UErrorCode *status);
			/**
			* Get the callback function for this URegularExpression.
			*
			* @param regexp The compiled regular expression.
			* @param callback Out paramater, receives a pointer to the user-suppl
			ied
			* callback function.
			* @param context Out parameter, receives the user context pointer th
			at
			* was set when uregex_setFindProgressCallback() was c
			alled.
			* @param status A reference to a UErrorCode to receive any errors.
			* @draft ICU 4.6
			*/
			U_DRAFT void U_EXPORT2
			uregex_getFindProgressCallback(const URegularExpression *regexp,
			URegexFindProgressCallback **callbac
			k,
			const void **context
			,
			UErrorCode *status);
	#endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */		#endif /* !UCONFIG_NO_REGULAR_EXPRESSIONS */
	#endif /* UREGEX_H */		#endif /* UREGEX_H */
End of changes. 1 change blocks.
	0 lines changed or deleted		75 lines changed or added

	urename.h		urename.h
	skipping to change at line 914		skipping to change at line 914
	#define ufmt_utop U_ICU_ENTRY_POINT_RENAME(ufmt_utop)		#define ufmt_utop U_ICU_ENTRY_POINT_RENAME(ufmt_utop)
	#define uhash_close U_ICU_ENTRY_POINT_RENAME(uhash_close)		#define uhash_close U_ICU_ENTRY_POINT_RENAME(uhash_close)
	#define uhash_compareCaselessUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_c ompareCaselessUnicodeString)		#define uhash_compareCaselessUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_c ompareCaselessUnicodeString)
	#define uhash_compareChars U_ICU_ENTRY_POINT_RENAME(uhash_compareChars)		#define uhash_compareChars U_ICU_ENTRY_POINT_RENAME(uhash_compareChars)
	#define uhash_compareIChars U_ICU_ENTRY_POINT_RENAME(uhash_compareIChars)		#define uhash_compareIChars U_ICU_ENTRY_POINT_RENAME(uhash_compareIChars)
	#define uhash_compareLong U_ICU_ENTRY_POINT_RENAME(uhash_compareLong)		#define uhash_compareLong U_ICU_ENTRY_POINT_RENAME(uhash_compareLong)
	#define uhash_compareUChars U_ICU_ENTRY_POINT_RENAME(uhash_compareUChars)		#define uhash_compareUChars U_ICU_ENTRY_POINT_RENAME(uhash_compareUChars)
	#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUn icodeString)		#define uhash_compareUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_compareUn icodeString)
	#define uhash_count U_ICU_ENTRY_POINT_RENAME(uhash_count)		#define uhash_count U_ICU_ENTRY_POINT_RENAME(uhash_count)
	#define uhash_deleteHashtable U_ICU_ENTRY_POINT_RENAME(uhash_deleteHashtabl e)		#define uhash_deleteHashtable U_ICU_ENTRY_POINT_RENAME(uhash_deleteHashtabl e)
	#define uhash_deleteUVector U_ICU_ENTRY_POINT_RENAME(uhash_deleteUVector)		#define uhash_deleteUObject U_ICU_ENTRY_POINT_RENAME(uhash_deleteUObject)
	#define uhash_deleteUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_deleteUnic odeString)		#define uhash_deleteUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_deleteUnic odeString)
	#define uhash_equals U_ICU_ENTRY_POINT_RENAME(uhash_equals)		#define uhash_equals U_ICU_ENTRY_POINT_RENAME(uhash_equals)
	#define uhash_find U_ICU_ENTRY_POINT_RENAME(uhash_find)		#define uhash_find U_ICU_ENTRY_POINT_RENAME(uhash_find)
	#define uhash_freeBlock U_ICU_ENTRY_POINT_RENAME(uhash_freeBlock)		#define uhash_freeBlock U_ICU_ENTRY_POINT_RENAME(uhash_freeBlock)
	#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get)		#define uhash_get U_ICU_ENTRY_POINT_RENAME(uhash_get)
	#define uhash_geti U_ICU_ENTRY_POINT_RENAME(uhash_geti)		#define uhash_geti U_ICU_ENTRY_POINT_RENAME(uhash_geti)
	#define uhash_hashCaselessUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_hash CaselessUnicodeString)		#define uhash_hashCaselessUnicodeString U_ICU_ENTRY_POINT_RENAME(uhash_hash CaselessUnicodeString)
	#define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars)		#define uhash_hashChars U_ICU_ENTRY_POINT_RENAME(uhash_hashChars)
	#define uhash_hashIChars U_ICU_ENTRY_POINT_RENAME(uhash_hashIChars)		#define uhash_hashIChars U_ICU_ENTRY_POINT_RENAME(uhash_hashIChars)
	#define uhash_hashLong U_ICU_ENTRY_POINT_RENAME(uhash_hashLong)		#define uhash_hashLong U_ICU_ENTRY_POINT_RENAME(uhash_hashLong)
	skipping to change at line 952		skipping to change at line 952
	#define uhash_removeElement U_ICU_ENTRY_POINT_RENAME(uhash_removeElement)		#define uhash_removeElement U_ICU_ENTRY_POINT_RENAME(uhash_removeElement)
	#define uhash_removei U_ICU_ENTRY_POINT_RENAME(uhash_removei)		#define uhash_removei U_ICU_ENTRY_POINT_RENAME(uhash_removei)
	#define uhash_setKeyComparator U_ICU_ENTRY_POINT_RENAME(uhash_setKeyCompara tor)		#define uhash_setKeyComparator U_ICU_ENTRY_POINT_RENAME(uhash_setKeyCompara tor)
	#define uhash_setKeyDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setKeyDeleter)		#define uhash_setKeyDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setKeyDeleter)
	#define uhash_setKeyHasher U_ICU_ENTRY_POINT_RENAME(uhash_setKeyHasher)		#define uhash_setKeyHasher U_ICU_ENTRY_POINT_RENAME(uhash_setKeyHasher)
	#define uhash_setResizePolicy U_ICU_ENTRY_POINT_RENAME(uhash_setResizePolic y)		#define uhash_setResizePolicy U_ICU_ENTRY_POINT_RENAME(uhash_setResizePolic y)
	#define uhash_setValueComparator U_ICU_ENTRY_POINT_RENAME(uhash_setValueCom parator)		#define uhash_setValueComparator U_ICU_ENTRY_POINT_RENAME(uhash_setValueCom parator)
	#define uhash_setValueDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setValueDelete r)		#define uhash_setValueDeleter U_ICU_ENTRY_POINT_RENAME(uhash_setValueDelete r)
	#define uidna_IDNToASCII U_ICU_ENTRY_POINT_RENAME(uidna_IDNToASCII)		#define uidna_IDNToASCII U_ICU_ENTRY_POINT_RENAME(uidna_IDNToASCII)
	#define uidna_IDNToUnicode U_ICU_ENTRY_POINT_RENAME(uidna_IDNToUnicode)		#define uidna_IDNToUnicode U_ICU_ENTRY_POINT_RENAME(uidna_IDNToUnicode)
			#define uidna_close U_ICU_ENTRY_POINT_RENAME(uidna_close)
	#define uidna_compare U_ICU_ENTRY_POINT_RENAME(uidna_compare)		#define uidna_compare U_ICU_ENTRY_POINT_RENAME(uidna_compare)
			#define uidna_labelToASCII U_ICU_ENTRY_POINT_RENAME(uidna_labelToASCII)
			#define uidna_labelToASCII_UTF8 U_ICU_ENTRY_POINT_RENAME(uidna_labelToASCII
			_UTF8)
			#define uidna_labelToUnicode U_ICU_ENTRY_POINT_RENAME(uidna_labelToUnicode)
			#define uidna_labelToUnicodeUTF8 U_ICU_ENTRY_POINT_RENAME(uidna_labelToUnic
			odeUTF8)
			#define uidna_nameToASCII U_ICU_ENTRY_POINT_RENAME(uidna_nameToASCII)
			#define uidna_nameToASCII_UTF8 U_ICU_ENTRY_POINT_RENAME(uidna_nameToASCII_U
			TF8)
			#define uidna_nameToUnicode U_ICU_ENTRY_POINT_RENAME(uidna_nameToUnicode)
			#define uidna_nameToUnicodeUTF8 U_ICU_ENTRY_POINT_RENAME(uidna_nameToUnicod
			eUTF8)
			#define uidna_openUTS46 U_ICU_ENTRY_POINT_RENAME(uidna_openUTS46)
	#define uidna_toASCII U_ICU_ENTRY_POINT_RENAME(uidna_toASCII)		#define uidna_toASCII U_ICU_ENTRY_POINT_RENAME(uidna_toASCII)
	#define uidna_toUnicode U_ICU_ENTRY_POINT_RENAME(uidna_toUnicode)		#define uidna_toUnicode U_ICU_ENTRY_POINT_RENAME(uidna_toUnicode)
	#define uiter_current32 U_ICU_ENTRY_POINT_RENAME(uiter_current32)		#define uiter_current32 U_ICU_ENTRY_POINT_RENAME(uiter_current32)
	#define uiter_getState U_ICU_ENTRY_POINT_RENAME(uiter_getState)		#define uiter_getState U_ICU_ENTRY_POINT_RENAME(uiter_getState)
	#define uiter_next32 U_ICU_ENTRY_POINT_RENAME(uiter_next32)		#define uiter_next32 U_ICU_ENTRY_POINT_RENAME(uiter_next32)
	#define uiter_previous32 U_ICU_ENTRY_POINT_RENAME(uiter_previous32)		#define uiter_previous32 U_ICU_ENTRY_POINT_RENAME(uiter_previous32)
	#define uiter_setCharacterIterator U_ICU_ENTRY_POINT_RENAME(uiter_setCharac terIterator)		#define uiter_setCharacterIterator U_ICU_ENTRY_POINT_RENAME(uiter_setCharac terIterator)
	#define uiter_setReplaceable U_ICU_ENTRY_POINT_RENAME(uiter_setReplaceable)		#define uiter_setReplaceable U_ICU_ENTRY_POINT_RENAME(uiter_setReplaceable)
	#define uiter_setState U_ICU_ENTRY_POINT_RENAME(uiter_setState)		#define uiter_setState U_ICU_ENTRY_POINT_RENAME(uiter_setState)
	#define uiter_setString U_ICU_ENTRY_POINT_RENAME(uiter_setString)		#define uiter_setString U_ICU_ENTRY_POINT_RENAME(uiter_setString)
	skipping to change at line 1066		skipping to change at line 1076
	#define umtx_atomic_dec U_ICU_ENTRY_POINT_RENAME(umtx_atomic_dec)		#define umtx_atomic_dec U_ICU_ENTRY_POINT_RENAME(umtx_atomic_dec)
	#define umtx_atomic_inc U_ICU_ENTRY_POINT_RENAME(umtx_atomic_inc)		#define umtx_atomic_inc U_ICU_ENTRY_POINT_RENAME(umtx_atomic_inc)
	#define umtx_cleanup U_ICU_ENTRY_POINT_RENAME(umtx_cleanup)		#define umtx_cleanup U_ICU_ENTRY_POINT_RENAME(umtx_cleanup)
	#define umtx_destroy U_ICU_ENTRY_POINT_RENAME(umtx_destroy)		#define umtx_destroy U_ICU_ENTRY_POINT_RENAME(umtx_destroy)
	#define umtx_init U_ICU_ENTRY_POINT_RENAME(umtx_init)		#define umtx_init U_ICU_ENTRY_POINT_RENAME(umtx_init)
	#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock)		#define umtx_lock U_ICU_ENTRY_POINT_RENAME(umtx_lock)
	#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock)		#define umtx_unlock U_ICU_ENTRY_POINT_RENAME(umtx_unlock)
	#define uniset_getUnicode32Instance U_ICU_ENTRY_POINT_RENAME(uniset_getUnic ode32Instance)		#define uniset_getUnicode32Instance U_ICU_ENTRY_POINT_RENAME(uniset_getUnic ode32Instance)
	#define unorm2_append U_ICU_ENTRY_POINT_RENAME(unorm2_append)		#define unorm2_append U_ICU_ENTRY_POINT_RENAME(unorm2_append)
	#define unorm2_close U_ICU_ENTRY_POINT_RENAME(unorm2_close)		#define unorm2_close U_ICU_ENTRY_POINT_RENAME(unorm2_close)
			#define unorm2_getDecomposition U_ICU_ENTRY_POINT_RENAME(unorm2_getDecompos ition)
	#define unorm2_getInstance U_ICU_ENTRY_POINT_RENAME(unorm2_getInstance)		#define unorm2_getInstance U_ICU_ENTRY_POINT_RENAME(unorm2_getInstance)
	#define unorm2_hasBoundaryAfter U_ICU_ENTRY_POINT_RENAME(unorm2_hasBoundary After)		#define unorm2_hasBoundaryAfter U_ICU_ENTRY_POINT_RENAME(unorm2_hasBoundary After)
	#define unorm2_hasBoundaryBefore U_ICU_ENTRY_POINT_RENAME(unorm2_hasBoundar yBefore)		#define unorm2_hasBoundaryBefore U_ICU_ENTRY_POINT_RENAME(unorm2_hasBoundar yBefore)
	#define unorm2_isInert U_ICU_ENTRY_POINT_RENAME(unorm2_isInert)		#define unorm2_isInert U_ICU_ENTRY_POINT_RENAME(unorm2_isInert)
	#define unorm2_isNormalized U_ICU_ENTRY_POINT_RENAME(unorm2_isNormalized)		#define unorm2_isNormalized U_ICU_ENTRY_POINT_RENAME(unorm2_isNormalized)
	#define unorm2_normalize U_ICU_ENTRY_POINT_RENAME(unorm2_normalize)		#define unorm2_normalize U_ICU_ENTRY_POINT_RENAME(unorm2_normalize)
	#define unorm2_normalizeSecondAndAppend U_ICU_ENTRY_POINT_RENAME(unorm2_nor malizeSecondAndAppend)		#define unorm2_normalizeSecondAndAppend U_ICU_ENTRY_POINT_RENAME(unorm2_nor malizeSecondAndAppend)
	#define unorm2_openFiltered U_ICU_ENTRY_POINT_RENAME(unorm2_openFiltered)		#define unorm2_openFiltered U_ICU_ENTRY_POINT_RENAME(unorm2_openFiltered)
	#define unorm2_quickCheck U_ICU_ENTRY_POINT_RENAME(unorm2_quickCheck)		#define unorm2_quickCheck U_ICU_ENTRY_POINT_RENAME(unorm2_quickCheck)
	#define unorm2_spanQuickCheckYes U_ICU_ENTRY_POINT_RENAME(unorm2_spanQuickC heckYes)		#define unorm2_spanQuickCheckYes U_ICU_ENTRY_POINT_RENAME(unorm2_spanQuickC heckYes)
	#define unorm2_swap U_ICU_ENTRY_POINT_RENAME(unorm2_swap)		#define unorm2_swap U_ICU_ENTRY_POINT_RENAME(unorm2_swap)
	#define unorm_addPropertyStarts U_ICU_ENTRY_POINT_RENAME(unorm_addPropertyS tarts)
	#define unorm_closeIter U_ICU_ENTRY_POINT_RENAME(unorm_closeIter)		#define unorm_closeIter U_ICU_ENTRY_POINT_RENAME(unorm_closeIter)
	#define unorm_compare U_ICU_ENTRY_POINT_RENAME(unorm_compare)		#define unorm_compare U_ICU_ENTRY_POINT_RENAME(unorm_compare)
	#define unorm_concatenate U_ICU_ENTRY_POINT_RENAME(unorm_concatenate)		#define unorm_concatenate U_ICU_ENTRY_POINT_RENAME(unorm_concatenate)
	#define unorm_getCanonStartSet U_ICU_ENTRY_POINT_RENAME(unorm_getCanonStart Set)
	#define unorm_getFCDTrieIndex U_ICU_ENTRY_POINT_RENAME(unorm_getFCDTrieInde x)		#define unorm_getFCDTrieIndex U_ICU_ENTRY_POINT_RENAME(unorm_getFCDTrieInde x)
	#define unorm_getQuickCheck U_ICU_ENTRY_POINT_RENAME(unorm_getQuickCheck)		#define unorm_getQuickCheck U_ICU_ENTRY_POINT_RENAME(unorm_getQuickCheck)
	#define unorm_haveData U_ICU_ENTRY_POINT_RENAME(unorm_haveData)
	#define unorm_isCanonSafeStart U_ICU_ENTRY_POINT_RENAME(unorm_isCanonSafeSt
	art)
	#define unorm_isNormalized U_ICU_ENTRY_POINT_RENAME(unorm_isNormalized)		#define unorm_isNormalized U_ICU_ENTRY_POINT_RENAME(unorm_isNormalized)
	#define unorm_isNormalizedWithOptions U_ICU_ENTRY_POINT_RENAME(unorm_isNorm alizedWithOptions)		#define unorm_isNormalizedWithOptions U_ICU_ENTRY_POINT_RENAME(unorm_isNorm alizedWithOptions)
	#define unorm_next U_ICU_ENTRY_POINT_RENAME(unorm_next)		#define unorm_next U_ICU_ENTRY_POINT_RENAME(unorm_next)
	#define unorm_normalize U_ICU_ENTRY_POINT_RENAME(unorm_normalize)		#define unorm_normalize U_ICU_ENTRY_POINT_RENAME(unorm_normalize)
	#define unorm_openIter U_ICU_ENTRY_POINT_RENAME(unorm_openIter)		#define unorm_openIter U_ICU_ENTRY_POINT_RENAME(unorm_openIter)
	#define unorm_previous U_ICU_ENTRY_POINT_RENAME(unorm_previous)		#define unorm_previous U_ICU_ENTRY_POINT_RENAME(unorm_previous)
	#define unorm_quickCheck U_ICU_ENTRY_POINT_RENAME(unorm_quickCheck)		#define unorm_quickCheck U_ICU_ENTRY_POINT_RENAME(unorm_quickCheck)
	#define unorm_quickCheckWithOptions U_ICU_ENTRY_POINT_RENAME(unorm_quickChe ckWithOptions)		#define unorm_quickCheckWithOptions U_ICU_ENTRY_POINT_RENAME(unorm_quickChe ckWithOptions)
	#define unorm_setIter U_ICU_ENTRY_POINT_RENAME(unorm_setIter)		#define unorm_setIter U_ICU_ENTRY_POINT_RENAME(unorm_setIter)
	#define unum_applyPattern U_ICU_ENTRY_POINT_RENAME(unum_applyPattern)		#define unum_applyPattern U_ICU_ENTRY_POINT_RENAME(unum_applyPattern)
	skipping to change at line 1268		skipping to change at line 1275
	#define uprv_fmin U_ICU_ENTRY_POINT_RENAME(uprv_fmin)		#define uprv_fmin U_ICU_ENTRY_POINT_RENAME(uprv_fmin)
	#define uprv_fmod U_ICU_ENTRY_POINT_RENAME(uprv_fmod)		#define uprv_fmod U_ICU_ENTRY_POINT_RENAME(uprv_fmod)
	#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free)		#define uprv_free U_ICU_ENTRY_POINT_RENAME(uprv_free)
	#define uprv_getCharNameCharacters U_ICU_ENTRY_POINT_RENAME(uprv_getCharNam eCharacters)		#define uprv_getCharNameCharacters U_ICU_ENTRY_POINT_RENAME(uprv_getCharNam eCharacters)
	#define uprv_getDefaultCodepage U_ICU_ENTRY_POINT_RENAME(uprv_getDefaultCod epage)		#define uprv_getDefaultCodepage U_ICU_ENTRY_POINT_RENAME(uprv_getDefaultCod epage)
	#define uprv_getDefaultLocaleID U_ICU_ENTRY_POINT_RENAME(uprv_getDefaultLoc aleID)		#define uprv_getDefaultLocaleID U_ICU_ENTRY_POINT_RENAME(uprv_getDefaultLoc aleID)
	#define uprv_getInfinity U_ICU_ENTRY_POINT_RENAME(uprv_getInfinity)		#define uprv_getInfinity U_ICU_ENTRY_POINT_RENAME(uprv_getInfinity)
	#define uprv_getMaxCharNameLength U_ICU_ENTRY_POINT_RENAME(uprv_getMaxCharN ameLength)		#define uprv_getMaxCharNameLength U_ICU_ENTRY_POINT_RENAME(uprv_getMaxCharN ameLength)
	#define uprv_getMaxValues U_ICU_ENTRY_POINT_RENAME(uprv_getMaxValues)		#define uprv_getMaxValues U_ICU_ENTRY_POINT_RENAME(uprv_getMaxValues)
	#define uprv_getNaN U_ICU_ENTRY_POINT_RENAME(uprv_getNaN)		#define uprv_getNaN U_ICU_ENTRY_POINT_RENAME(uprv_getNaN)
			#define uprv_getRawUTCtime U_ICU_ENTRY_POINT_RENAME(uprv_getRawUTCtime)
	#define uprv_getStaticCurrencyName U_ICU_ENTRY_POINT_RENAME(uprv_getStaticC urrencyName)		#define uprv_getStaticCurrencyName U_ICU_ENTRY_POINT_RENAME(uprv_getStaticC urrencyName)
	#define uprv_getUTCtime U_ICU_ENTRY_POINT_RENAME(uprv_getUTCtime)		#define uprv_getUTCtime U_ICU_ENTRY_POINT_RENAME(uprv_getUTCtime)
	#define uprv_haveProperties U_ICU_ENTRY_POINT_RENAME(uprv_haveProperties)		#define uprv_haveProperties U_ICU_ENTRY_POINT_RENAME(uprv_haveProperties)
	#define uprv_init_collIterate U_ICU_ENTRY_POINT_RENAME(uprv_init_collIterat e)		#define uprv_init_collIterate U_ICU_ENTRY_POINT_RENAME(uprv_init_collIterat e)
	#define uprv_init_pce U_ICU_ENTRY_POINT_RENAME(uprv_init_pce)		#define uprv_init_pce U_ICU_ENTRY_POINT_RENAME(uprv_init_pce)
	#define uprv_int32Comparator U_ICU_ENTRY_POINT_RENAME(uprv_int32Comparator)		#define uprv_int32Comparator U_ICU_ENTRY_POINT_RENAME(uprv_int32Comparator)
	#define uprv_isInfinite U_ICU_ENTRY_POINT_RENAME(uprv_isInfinite)		#define uprv_isInfinite U_ICU_ENTRY_POINT_RENAME(uprv_isInfinite)
	#define uprv_isInvariantString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantStr ing)		#define uprv_isInvariantString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantStr ing)
	#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUS tring)		#define uprv_isInvariantUString U_ICU_ENTRY_POINT_RENAME(uprv_isInvariantUS tring)
	#define uprv_isNaN U_ICU_ENTRY_POINT_RENAME(uprv_isNaN)		#define uprv_isNaN U_ICU_ENTRY_POINT_RENAME(uprv_isNaN)
	skipping to change at line 1342		skipping to change at line 1350
	#define uregex_appendReplacement U_ICU_ENTRY_POINT_RENAME(uregex_appendRepl acement)		#define uregex_appendReplacement U_ICU_ENTRY_POINT_RENAME(uregex_appendRepl acement)
	#define uregex_appendReplacementUText U_ICU_ENTRY_POINT_RENAME(uregex_appen dReplacementUText)		#define uregex_appendReplacementUText U_ICU_ENTRY_POINT_RENAME(uregex_appen dReplacementUText)
	#define uregex_appendTail U_ICU_ENTRY_POINT_RENAME(uregex_appendTail)		#define uregex_appendTail U_ICU_ENTRY_POINT_RENAME(uregex_appendTail)
	#define uregex_appendTailUText U_ICU_ENTRY_POINT_RENAME(uregex_appendTailUT ext)		#define uregex_appendTailUText U_ICU_ENTRY_POINT_RENAME(uregex_appendTailUT ext)
	#define uregex_clone U_ICU_ENTRY_POINT_RENAME(uregex_clone)		#define uregex_clone U_ICU_ENTRY_POINT_RENAME(uregex_clone)
	#define uregex_close U_ICU_ENTRY_POINT_RENAME(uregex_close)		#define uregex_close U_ICU_ENTRY_POINT_RENAME(uregex_close)
	#define uregex_end U_ICU_ENTRY_POINT_RENAME(uregex_end)		#define uregex_end U_ICU_ENTRY_POINT_RENAME(uregex_end)
	#define uregex_find U_ICU_ENTRY_POINT_RENAME(uregex_find)		#define uregex_find U_ICU_ENTRY_POINT_RENAME(uregex_find)
	#define uregex_findNext U_ICU_ENTRY_POINT_RENAME(uregex_findNext)		#define uregex_findNext U_ICU_ENTRY_POINT_RENAME(uregex_findNext)
	#define uregex_flags U_ICU_ENTRY_POINT_RENAME(uregex_flags)		#define uregex_flags U_ICU_ENTRY_POINT_RENAME(uregex_flags)
			#define uregex_getFindProgressCallback U_ICU_ENTRY_POINT_RENAME(uregex_getF indProgressCallback)
	#define uregex_getMatchCallback U_ICU_ENTRY_POINT_RENAME(uregex_getMatchCal lback)		#define uregex_getMatchCallback U_ICU_ENTRY_POINT_RENAME(uregex_getMatchCal lback)
	#define uregex_getStackLimit U_ICU_ENTRY_POINT_RENAME(uregex_getStackLimit)		#define uregex_getStackLimit U_ICU_ENTRY_POINT_RENAME(uregex_getStackLimit)
	#define uregex_getText U_ICU_ENTRY_POINT_RENAME(uregex_getText)		#define uregex_getText U_ICU_ENTRY_POINT_RENAME(uregex_getText)
	#define uregex_getTimeLimit U_ICU_ENTRY_POINT_RENAME(uregex_getTimeLimit)		#define uregex_getTimeLimit U_ICU_ENTRY_POINT_RENAME(uregex_getTimeLimit)
	#define uregex_getUText U_ICU_ENTRY_POINT_RENAME(uregex_getUText)		#define uregex_getUText U_ICU_ENTRY_POINT_RENAME(uregex_getUText)
	#define uregex_group U_ICU_ENTRY_POINT_RENAME(uregex_group)		#define uregex_group U_ICU_ENTRY_POINT_RENAME(uregex_group)
	#define uregex_groupCount U_ICU_ENTRY_POINT_RENAME(uregex_groupCount)		#define uregex_groupCount U_ICU_ENTRY_POINT_RENAME(uregex_groupCount)
	#define uregex_groupUText U_ICU_ENTRY_POINT_RENAME(uregex_groupUText)		#define uregex_groupUText U_ICU_ENTRY_POINT_RENAME(uregex_groupUText)
	#define uregex_hasAnchoringBounds U_ICU_ENTRY_POINT_RENAME(uregex_hasAnchor ingBounds)		#define uregex_hasAnchoringBounds U_ICU_ENTRY_POINT_RENAME(uregex_hasAnchor ingBounds)
	#define uregex_hasTransparentBounds U_ICU_ENTRY_POINT_RENAME(uregex_hasTran sparentBounds)		#define uregex_hasTransparentBounds U_ICU_ENTRY_POINT_RENAME(uregex_hasTran sparentBounds)
	skipping to change at line 1368		skipping to change at line 1377
	#define uregex_pattern U_ICU_ENTRY_POINT_RENAME(uregex_pattern)		#define uregex_pattern U_ICU_ENTRY_POINT_RENAME(uregex_pattern)
	#define uregex_patternUText U_ICU_ENTRY_POINT_RENAME(uregex_patternUText)		#define uregex_patternUText U_ICU_ENTRY_POINT_RENAME(uregex_patternUText)
	#define uregex_regionEnd U_ICU_ENTRY_POINT_RENAME(uregex_regionEnd)		#define uregex_regionEnd U_ICU_ENTRY_POINT_RENAME(uregex_regionEnd)
	#define uregex_regionStart U_ICU_ENTRY_POINT_RENAME(uregex_regionStart)		#define uregex_regionStart U_ICU_ENTRY_POINT_RENAME(uregex_regionStart)
	#define uregex_replaceAll U_ICU_ENTRY_POINT_RENAME(uregex_replaceAll)		#define uregex_replaceAll U_ICU_ENTRY_POINT_RENAME(uregex_replaceAll)
	#define uregex_replaceAllUText U_ICU_ENTRY_POINT_RENAME(uregex_replaceAllUT ext)		#define uregex_replaceAllUText U_ICU_ENTRY_POINT_RENAME(uregex_replaceAllUT ext)
	#define uregex_replaceFirst U_ICU_ENTRY_POINT_RENAME(uregex_replaceFirst)		#define uregex_replaceFirst U_ICU_ENTRY_POINT_RENAME(uregex_replaceFirst)
	#define uregex_replaceFirstUText U_ICU_ENTRY_POINT_RENAME(uregex_replaceFir stUText)		#define uregex_replaceFirstUText U_ICU_ENTRY_POINT_RENAME(uregex_replaceFir stUText)
	#define uregex_requireEnd U_ICU_ENTRY_POINT_RENAME(uregex_requireEnd)		#define uregex_requireEnd U_ICU_ENTRY_POINT_RENAME(uregex_requireEnd)
	#define uregex_reset U_ICU_ENTRY_POINT_RENAME(uregex_reset)		#define uregex_reset U_ICU_ENTRY_POINT_RENAME(uregex_reset)
			#define uregex_setFindProgressCallback U_ICU_ENTRY_POINT_RENAME(uregex_setF indProgressCallback)
	#define uregex_setMatchCallback U_ICU_ENTRY_POINT_RENAME(uregex_setMatchCal lback)		#define uregex_setMatchCallback U_ICU_ENTRY_POINT_RENAME(uregex_setMatchCal lback)
	#define uregex_setRegion U_ICU_ENTRY_POINT_RENAME(uregex_setRegion)		#define uregex_setRegion U_ICU_ENTRY_POINT_RENAME(uregex_setRegion)
	#define uregex_setStackLimit U_ICU_ENTRY_POINT_RENAME(uregex_setStackLimit)		#define uregex_setStackLimit U_ICU_ENTRY_POINT_RENAME(uregex_setStackLimit)
	#define uregex_setText U_ICU_ENTRY_POINT_RENAME(uregex_setText)		#define uregex_setText U_ICU_ENTRY_POINT_RENAME(uregex_setText)
	#define uregex_setTimeLimit U_ICU_ENTRY_POINT_RENAME(uregex_setTimeLimit)		#define uregex_setTimeLimit U_ICU_ENTRY_POINT_RENAME(uregex_setTimeLimit)
	#define uregex_setUText U_ICU_ENTRY_POINT_RENAME(uregex_setUText)		#define uregex_setUText U_ICU_ENTRY_POINT_RENAME(uregex_setUText)
	#define uregex_split U_ICU_ENTRY_POINT_RENAME(uregex_split)		#define uregex_split U_ICU_ENTRY_POINT_RENAME(uregex_split)
	#define uregex_splitUText U_ICU_ENTRY_POINT_RENAME(uregex_splitUText)		#define uregex_splitUText U_ICU_ENTRY_POINT_RENAME(uregex_splitUText)
	#define uregex_start U_ICU_ENTRY_POINT_RENAME(uregex_start)		#define uregex_start U_ICU_ENTRY_POINT_RENAME(uregex_start)
	#define uregex_ucstr_unescape_charAt U_ICU_ENTRY_POINT_RENAME(uregex_ucstr_ unescape_charAt)		#define uregex_ucstr_unescape_charAt U_ICU_ENTRY_POINT_RENAME(uregex_ucstr_ unescape_charAt)
	skipping to change at line 1397		skipping to change at line 1407
	#define ures_getByIndex U_ICU_ENTRY_POINT_RENAME(ures_getByIndex)		#define ures_getByIndex U_ICU_ENTRY_POINT_RENAME(ures_getByIndex)
	#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey)		#define ures_getByKey U_ICU_ENTRY_POINT_RENAME(ures_getByKey)
	#define ures_getByKeyWithFallback U_ICU_ENTRY_POINT_RENAME(ures_getByKeyWit hFallback)		#define ures_getByKeyWithFallback U_ICU_ENTRY_POINT_RENAME(ures_getByKeyWit hFallback)
	#define ures_getFunctionalEquivalent U_ICU_ENTRY_POINT_RENAME(ures_getFunct ionalEquivalent)		#define ures_getFunctionalEquivalent U_ICU_ENTRY_POINT_RENAME(ures_getFunct ionalEquivalent)
	#define ures_getInt U_ICU_ENTRY_POINT_RENAME(ures_getInt)		#define ures_getInt U_ICU_ENTRY_POINT_RENAME(ures_getInt)
	#define ures_getIntVector U_ICU_ENTRY_POINT_RENAME(ures_getIntVector)		#define ures_getIntVector U_ICU_ENTRY_POINT_RENAME(ures_getIntVector)
	#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey)		#define ures_getKey U_ICU_ENTRY_POINT_RENAME(ures_getKey)
	#define ures_getKeywordValues U_ICU_ENTRY_POINT_RENAME(ures_getKeywordValue s)		#define ures_getKeywordValues U_ICU_ENTRY_POINT_RENAME(ures_getKeywordValue s)
	#define ures_getLocale U_ICU_ENTRY_POINT_RENAME(ures_getLocale)		#define ures_getLocale U_ICU_ENTRY_POINT_RENAME(ures_getLocale)
	#define ures_getLocaleByType U_ICU_ENTRY_POINT_RENAME(ures_getLocaleByType)		#define ures_getLocaleByType U_ICU_ENTRY_POINT_RENAME(ures_getLocaleByType)
			#define ures_getLocaleInternal U_ICU_ENTRY_POINT_RENAME(ures_getLocaleInter nal)
	#define ures_getName U_ICU_ENTRY_POINT_RENAME(ures_getName)		#define ures_getName U_ICU_ENTRY_POINT_RENAME(ures_getName)
	#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource)		#define ures_getNextResource U_ICU_ENTRY_POINT_RENAME(ures_getNextResource)
	#define ures_getNextString U_ICU_ENTRY_POINT_RENAME(ures_getNextString)		#define ures_getNextString U_ICU_ENTRY_POINT_RENAME(ures_getNextString)
	#define ures_getSize U_ICU_ENTRY_POINT_RENAME(ures_getSize)		#define ures_getSize U_ICU_ENTRY_POINT_RENAME(ures_getSize)
	#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString)		#define ures_getString U_ICU_ENTRY_POINT_RENAME(ures_getString)
	#define ures_getStringByIndex U_ICU_ENTRY_POINT_RENAME(ures_getStringByInde x)		#define ures_getStringByIndex U_ICU_ENTRY_POINT_RENAME(ures_getStringByInde x)
	#define ures_getStringByKey U_ICU_ENTRY_POINT_RENAME(ures_getStringByKey)		#define ures_getStringByKey U_ICU_ENTRY_POINT_RENAME(ures_getStringByKey)
	#define ures_getStringByKeyWithFallback U_ICU_ENTRY_POINT_RENAME(ures_getSt ringByKeyWithFallback)		#define ures_getStringByKeyWithFallback U_ICU_ENTRY_POINT_RENAME(ures_getSt ringByKeyWithFallback)
	#define ures_getType U_ICU_ENTRY_POINT_RENAME(ures_getType)		#define ures_getType U_ICU_ENTRY_POINT_RENAME(ures_getType)
	#define ures_getUInt U_ICU_ENTRY_POINT_RENAME(ures_getUInt)		#define ures_getUInt U_ICU_ENTRY_POINT_RENAME(ures_getUInt)
	#define ures_getUTF8String U_ICU_ENTRY_POINT_RENAME(ures_getUTF8String)		#define ures_getUTF8String U_ICU_ENTRY_POINT_RENAME(ures_getUTF8String)
	#define ures_getUTF8StringByIndex U_ICU_ENTRY_POINT_RENAME(ures_getUTF8Stri ngByIndex)		#define ures_getUTF8StringByIndex U_ICU_ENTRY_POINT_RENAME(ures_getUTF8Stri ngByIndex)
	#define ures_getUTF8StringByKey U_ICU_ENTRY_POINT_RENAME(ures_getUTF8String ByKey)		#define ures_getUTF8StringByKey U_ICU_ENTRY_POINT_RENAME(ures_getUTF8String ByKey)
	#define ures_getVersion U_ICU_ENTRY_POINT_RENAME(ures_getVersion)		#define ures_getVersion U_ICU_ENTRY_POINT_RENAME(ures_getVersion)
	#define ures_getVersionByKey U_ICU_ENTRY_POINT_RENAME(ures_getVersionByKey)		#define ures_getVersionByKey U_ICU_ENTRY_POINT_RENAME(ures_getVersionByKey)
	#define ures_getVersionNumber U_ICU_ENTRY_POINT_RENAME(ures_getVersionNumbe r)		#define ures_getVersionNumber U_ICU_ENTRY_POINT_RENAME(ures_getVersionNumbe r)
			#define ures_getVersionNumberInternal U_ICU_ENTRY_POINT_RENAME(ures_getVers ionNumberInternal)
	#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext)		#define ures_hasNext U_ICU_ENTRY_POINT_RENAME(ures_hasNext)
	#define ures_initStackObject U_ICU_ENTRY_POINT_RENAME(ures_initStackObject)		#define ures_initStackObject U_ICU_ENTRY_POINT_RENAME(ures_initStackObject)
	#define ures_open U_ICU_ENTRY_POINT_RENAME(ures_open)		#define ures_open U_ICU_ENTRY_POINT_RENAME(ures_open)
	#define ures_openAvailableLocales U_ICU_ENTRY_POINT_RENAME(ures_openAvailab leLocales)		#define ures_openAvailableLocales U_ICU_ENTRY_POINT_RENAME(ures_openAvailab leLocales)
	#define ures_openDirect U_ICU_ENTRY_POINT_RENAME(ures_openDirect)		#define ures_openDirect U_ICU_ENTRY_POINT_RENAME(ures_openDirect)
	#define ures_openFillIn U_ICU_ENTRY_POINT_RENAME(ures_openFillIn)		#define ures_openFillIn U_ICU_ENTRY_POINT_RENAME(ures_openFillIn)
	#define ures_openU U_ICU_ENTRY_POINT_RENAME(ures_openU)		#define ures_openU U_ICU_ENTRY_POINT_RENAME(ures_openU)
	#define ures_resetIterator U_ICU_ENTRY_POINT_RENAME(ures_resetIterator)		#define ures_resetIterator U_ICU_ENTRY_POINT_RENAME(ures_resetIterator)
	#define ures_swap U_ICU_ENTRY_POINT_RENAME(ures_swap)		#define ures_swap U_ICU_ENTRY_POINT_RENAME(ures_swap)
	#define uscript_closeRun U_ICU_ENTRY_POINT_RENAME(uscript_closeRun)		#define uscript_closeRun U_ICU_ENTRY_POINT_RENAME(uscript_closeRun)
	skipping to change at line 1744		skipping to change at line 1756
	#define CEBuffer U_ICU_ENTRY_POINT_RENAME(CEBuffer)		#define CEBuffer U_ICU_ENTRY_POINT_RENAME(CEBuffer)
	#define CECalendar U_ICU_ENTRY_POINT_RENAME(CECalendar)		#define CECalendar U_ICU_ENTRY_POINT_RENAME(CECalendar)
	#define CEList U_ICU_ENTRY_POINT_RENAME(CEList)		#define CEList U_ICU_ENTRY_POINT_RENAME(CEList)
	#define CEToStringsMap U_ICU_ENTRY_POINT_RENAME(CEToStringsMap)		#define CEToStringsMap U_ICU_ENTRY_POINT_RENAME(CEToStringsMap)
	#define CFactory U_ICU_ENTRY_POINT_RENAME(CFactory)		#define CFactory U_ICU_ENTRY_POINT_RENAME(CFactory)
	#define Calendar U_ICU_ENTRY_POINT_RENAME(Calendar)		#define Calendar U_ICU_ENTRY_POINT_RENAME(Calendar)
	#define CalendarAstronomer U_ICU_ENTRY_POINT_RENAME(CalendarAstronomer)		#define CalendarAstronomer U_ICU_ENTRY_POINT_RENAME(CalendarAstronomer)
	#define CalendarCache U_ICU_ENTRY_POINT_RENAME(CalendarCache)		#define CalendarCache U_ICU_ENTRY_POINT_RENAME(CalendarCache)
	#define CalendarData U_ICU_ENTRY_POINT_RENAME(CalendarData)		#define CalendarData U_ICU_ENTRY_POINT_RENAME(CalendarData)
	#define CalendarService U_ICU_ENTRY_POINT_RENAME(CalendarService)		#define CalendarService U_ICU_ENTRY_POINT_RENAME(CalendarService)
			#define CanonIterData U_ICU_ENTRY_POINT_RENAME(CanonIterData)
			#define CanonIterDataSingleton U_ICU_ENTRY_POINT_RENAME(CanonIterDataSingle
			ton)
	#define CanonMarkFilter U_ICU_ENTRY_POINT_RENAME(CanonMarkFilter)		#define CanonMarkFilter U_ICU_ENTRY_POINT_RENAME(CanonMarkFilter)
	#define CanonShaping U_ICU_ENTRY_POINT_RENAME(CanonShaping)		#define CanonShaping U_ICU_ENTRY_POINT_RENAME(CanonShaping)
	#define CanonicalIterator U_ICU_ENTRY_POINT_RENAME(CanonicalIterator)		#define CanonicalIterator U_ICU_ENTRY_POINT_RENAME(CanonicalIterator)
	#define CaseMapTransliterator U_ICU_ENTRY_POINT_RENAME(CaseMapTransliterato r)		#define CaseMapTransliterator U_ICU_ENTRY_POINT_RENAME(CaseMapTransliterato r)
	#define ChainingContextualSubstitutionFormat1Subtable U_ICU_ENTRY_POINT_REN AME(ChainingContextualSubstitutionFormat1Subtable)		#define ChainingContextualSubstitutionFormat1Subtable U_ICU_ENTRY_POINT_REN AME(ChainingContextualSubstitutionFormat1Subtable)
	#define ChainingContextualSubstitutionFormat2Subtable U_ICU_ENTRY_POINT_REN AME(ChainingContextualSubstitutionFormat2Subtable)		#define ChainingContextualSubstitutionFormat2Subtable U_ICU_ENTRY_POINT_REN AME(ChainingContextualSubstitutionFormat2Subtable)
	#define ChainingContextualSubstitutionFormat3Subtable U_ICU_ENTRY_POINT_REN AME(ChainingContextualSubstitutionFormat3Subtable)		#define ChainingContextualSubstitutionFormat3Subtable U_ICU_ENTRY_POINT_REN AME(ChainingContextualSubstitutionFormat3Subtable)
	#define ChainingContextualSubstitutionSubtable U_ICU_ENTRY_POINT_RENAME(Cha iningContextualSubstitutionSubtable)		#define ChainingContextualSubstitutionSubtable U_ICU_ENTRY_POINT_RENAME(Cha iningContextualSubstitutionSubtable)
			#define CharString U_ICU_ENTRY_POINT_RENAME(CharString)
	#define CharSubstitutionFilter U_ICU_ENTRY_POINT_RENAME(CharSubstitutionFil ter)		#define CharSubstitutionFilter U_ICU_ENTRY_POINT_RENAME(CharSubstitutionFil ter)
	#define CharacterIterator U_ICU_ENTRY_POINT_RENAME(CharacterIterator)		#define CharacterIterator U_ICU_ENTRY_POINT_RENAME(CharacterIterator)
	#define CharacterNode U_ICU_ENTRY_POINT_RENAME(CharacterNode)		#define CharacterNode U_ICU_ENTRY_POINT_RENAME(CharacterNode)
	#define CharsetDetector U_ICU_ENTRY_POINT_RENAME(CharsetDetector)		#define CharsetDetector U_ICU_ENTRY_POINT_RENAME(CharsetDetector)
	#define CharsetMatch U_ICU_ENTRY_POINT_RENAME(CharsetMatch)		#define CharsetMatch U_ICU_ENTRY_POINT_RENAME(CharsetMatch)
	#define CharsetRecog_2022 U_ICU_ENTRY_POINT_RENAME(CharsetRecog_2022)		#define CharsetRecog_2022 U_ICU_ENTRY_POINT_RENAME(CharsetRecog_2022)
	#define CharsetRecog_2022CN U_ICU_ENTRY_POINT_RENAME(CharsetRecog_2022CN)		#define CharsetRecog_2022CN U_ICU_ENTRY_POINT_RENAME(CharsetRecog_2022CN)
	#define CharsetRecog_2022JP U_ICU_ENTRY_POINT_RENAME(CharsetRecog_2022JP)		#define CharsetRecog_2022JP U_ICU_ENTRY_POINT_RENAME(CharsetRecog_2022JP)
	#define CharsetRecog_2022KR U_ICU_ENTRY_POINT_RENAME(CharsetRecog_2022KR)		#define CharsetRecog_2022KR U_ICU_ENTRY_POINT_RENAME(CharsetRecog_2022KR)
	#define CharsetRecog_8859_1 U_ICU_ENTRY_POINT_RENAME(CharsetRecog_8859_1)		#define CharsetRecog_8859_1 U_ICU_ENTRY_POINT_RENAME(CharsetRecog_8859_1)
	skipping to change at line 1860		skipping to change at line 1875
	#define DateFormat U_ICU_ENTRY_POINT_RENAME(DateFormat)		#define DateFormat U_ICU_ENTRY_POINT_RENAME(DateFormat)
	#define DateFormatSymbols U_ICU_ENTRY_POINT_RENAME(DateFormatSymbols)		#define DateFormatSymbols U_ICU_ENTRY_POINT_RENAME(DateFormatSymbols)
	#define DateInterval U_ICU_ENTRY_POINT_RENAME(DateInterval)		#define DateInterval U_ICU_ENTRY_POINT_RENAME(DateInterval)
	#define DateIntervalFormat U_ICU_ENTRY_POINT_RENAME(DateIntervalFormat)		#define DateIntervalFormat U_ICU_ENTRY_POINT_RENAME(DateIntervalFormat)
	#define DateIntervalInfo U_ICU_ENTRY_POINT_RENAME(DateIntervalInfo)		#define DateIntervalInfo U_ICU_ENTRY_POINT_RENAME(DateIntervalInfo)
	#define DateTimeMatcher U_ICU_ENTRY_POINT_RENAME(DateTimeMatcher)		#define DateTimeMatcher U_ICU_ENTRY_POINT_RENAME(DateTimeMatcher)
	#define DateTimePatternGenerator U_ICU_ENTRY_POINT_RENAME(DateTimePatternGe nerator)		#define DateTimePatternGenerator U_ICU_ENTRY_POINT_RENAME(DateTimePatternGe nerator)
	#define DateTimeRule U_ICU_ENTRY_POINT_RENAME(DateTimeRule)		#define DateTimeRule U_ICU_ENTRY_POINT_RENAME(DateTimeRule)
	#define DecimalFormat U_ICU_ENTRY_POINT_RENAME(DecimalFormat)		#define DecimalFormat U_ICU_ENTRY_POINT_RENAME(DecimalFormat)
	#define DecimalFormatSymbols U_ICU_ENTRY_POINT_RENAME(DecimalFormatSymbols)		#define DecimalFormatSymbols U_ICU_ENTRY_POINT_RENAME(DecimalFormatSymbols)
	#define DecimalNumberString U_ICU_ENTRY_POINT_RENAME(DecimalNumberString)
	#define DecomposeNormalizer2 U_ICU_ENTRY_POINT_RENAME(DecomposeNormalizer2)		#define DecomposeNormalizer2 U_ICU_ENTRY_POINT_RENAME(DecomposeNormalizer2)
	#define DefaultCalendarFactory U_ICU_ENTRY_POINT_RENAME(DefaultCalendarFact ory)		#define DefaultCalendarFactory U_ICU_ENTRY_POINT_RENAME(DefaultCalendarFact ory)
	#define DefaultCharMapper U_ICU_ENTRY_POINT_RENAME(DefaultCharMapper)		#define DefaultCharMapper U_ICU_ENTRY_POINT_RENAME(DefaultCharMapper)
	#define DeviceTable U_ICU_ENTRY_POINT_RENAME(DeviceTable)		#define DeviceTable U_ICU_ENTRY_POINT_RENAME(DeviceTable)
	#define DictionaryBreakEngine U_ICU_ENTRY_POINT_RENAME(DictionaryBreakEngin e)		#define DictionaryBreakEngine U_ICU_ENTRY_POINT_RENAME(DictionaryBreakEngin e)
	#define DigitList U_ICU_ENTRY_POINT_RENAME(DigitList)		#define DigitList U_ICU_ENTRY_POINT_RENAME(DigitList)
	#define DistanceInfo U_ICU_ENTRY_POINT_RENAME(DistanceInfo)		#define DistanceInfo U_ICU_ENTRY_POINT_RENAME(DistanceInfo)
	#define EnumToOffset U_ICU_ENTRY_POINT_RENAME(EnumToOffset)		#define EnumToOffset U_ICU_ENTRY_POINT_RENAME(EnumToOffset)
	#define ErrorCode U_ICU_ENTRY_POINT_RENAME(ErrorCode)		#define ErrorCode U_ICU_ENTRY_POINT_RENAME(ErrorCode)
	#define EscapeTransliterator U_ICU_ENTRY_POINT_RENAME(EscapeTransliterator)		#define EscapeTransliterator U_ICU_ENTRY_POINT_RENAME(EscapeTransliterator)
	skipping to change at line 1926		skipping to change at line 1940
	#define ICULanguageBreakFactory U_ICU_ENTRY_POINT_RENAME(ICULanguageBreakFa ctory)		#define ICULanguageBreakFactory U_ICU_ENTRY_POINT_RENAME(ICULanguageBreakFa ctory)
	#define ICULocaleService U_ICU_ENTRY_POINT_RENAME(ICULocaleService)		#define ICULocaleService U_ICU_ENTRY_POINT_RENAME(ICULocaleService)
	#define ICUNotifier U_ICU_ENTRY_POINT_RENAME(ICUNotifier)		#define ICUNotifier U_ICU_ENTRY_POINT_RENAME(ICUNotifier)
	#define ICUNumberFormatFactory U_ICU_ENTRY_POINT_RENAME(ICUNumberFormatFact ory)		#define ICUNumberFormatFactory U_ICU_ENTRY_POINT_RENAME(ICUNumberFormatFact ory)
	#define ICUNumberFormatService U_ICU_ENTRY_POINT_RENAME(ICUNumberFormatServ ice)		#define ICUNumberFormatService U_ICU_ENTRY_POINT_RENAME(ICUNumberFormatServ ice)
	#define ICUResourceBundleFactory U_ICU_ENTRY_POINT_RENAME(ICUResourceBundle Factory)		#define ICUResourceBundleFactory U_ICU_ENTRY_POINT_RENAME(ICUResourceBundle Factory)
	#define ICUService U_ICU_ENTRY_POINT_RENAME(ICUService)		#define ICUService U_ICU_ENTRY_POINT_RENAME(ICUService)
	#define ICUServiceFactory U_ICU_ENTRY_POINT_RENAME(ICUServiceFactory)		#define ICUServiceFactory U_ICU_ENTRY_POINT_RENAME(ICUServiceFactory)
	#define ICUServiceKey U_ICU_ENTRY_POINT_RENAME(ICUServiceKey)		#define ICUServiceKey U_ICU_ENTRY_POINT_RENAME(ICUServiceKey)
	#define ICU_Utility U_ICU_ENTRY_POINT_RENAME(ICU_Utility)		#define ICU_Utility U_ICU_ENTRY_POINT_RENAME(ICU_Utility)
			#define IDNA U_ICU_ENTRY_POINT_RENAME(IDNA)
	#define IndianCalendar U_ICU_ENTRY_POINT_RENAME(IndianCalendar)		#define IndianCalendar U_ICU_ENTRY_POINT_RENAME(IndianCalendar)
	#define IndicClassTable U_ICU_ENTRY_POINT_RENAME(IndicClassTable)		#define IndicClassTable U_ICU_ENTRY_POINT_RENAME(IndicClassTable)
	#define IndicOpenTypeLayoutEngine U_ICU_ENTRY_POINT_RENAME(IndicOpenTypeLay outEngine)		#define IndicOpenTypeLayoutEngine U_ICU_ENTRY_POINT_RENAME(IndicOpenTypeLay outEngine)
	#define IndicRearrangementProcessor U_ICU_ENTRY_POINT_RENAME(IndicRearrange mentProcessor)		#define IndicRearrangementProcessor U_ICU_ENTRY_POINT_RENAME(IndicRearrange mentProcessor)
	#define IndicReordering U_ICU_ENTRY_POINT_RENAME(IndicReordering)		#define IndicReordering U_ICU_ENTRY_POINT_RENAME(IndicReordering)
	#define InitialTimeZoneRule U_ICU_ENTRY_POINT_RENAME(InitialTimeZoneRule)		#define InitialTimeZoneRule U_ICU_ENTRY_POINT_RENAME(InitialTimeZoneRule)
	#define InputText U_ICU_ENTRY_POINT_RENAME(InputText)		#define InputText U_ICU_ENTRY_POINT_RENAME(InputText)
	#define IntegralPartSubstitution U_ICU_ENTRY_POINT_RENAME(IntegralPartSubst itution)		#define IntegralPartSubstitution U_ICU_ENTRY_POINT_RENAME(IntegralPartSubst itution)
	#define IslamicCalendar U_ICU_ENTRY_POINT_RENAME(IslamicCalendar)		#define IslamicCalendar U_ICU_ENTRY_POINT_RENAME(IslamicCalendar)
	#define IteratedChar U_ICU_ENTRY_POINT_RENAME(IteratedChar)		#define IteratedChar U_ICU_ENTRY_POINT_RENAME(IteratedChar)
	skipping to change at line 2147		skipping to change at line 2162
	#define TransliteratorEntry U_ICU_ENTRY_POINT_RENAME(TransliteratorEntry)		#define TransliteratorEntry U_ICU_ENTRY_POINT_RENAME(TransliteratorEntry)
	#define TransliteratorIDParser U_ICU_ENTRY_POINT_RENAME(TransliteratorIDPar ser)		#define TransliteratorIDParser U_ICU_ENTRY_POINT_RENAME(TransliteratorIDPar ser)
	#define TransliteratorParser U_ICU_ENTRY_POINT_RENAME(TransliteratorParser)		#define TransliteratorParser U_ICU_ENTRY_POINT_RENAME(TransliteratorParser)
	#define TransliteratorRegistry U_ICU_ENTRY_POINT_RENAME(TransliteratorRegis try)		#define TransliteratorRegistry U_ICU_ENTRY_POINT_RENAME(TransliteratorRegis try)
	#define TransliteratorSpec U_ICU_ENTRY_POINT_RENAME(TransliteratorSpec)		#define TransliteratorSpec U_ICU_ENTRY_POINT_RENAME(TransliteratorSpec)
	#define TriStateSingleton U_ICU_ENTRY_POINT_RENAME(TriStateSingleton)		#define TriStateSingleton U_ICU_ENTRY_POINT_RENAME(TriStateSingleton)
	#define TrieWordDictionary U_ICU_ENTRY_POINT_RENAME(TrieWordDictionary)		#define TrieWordDictionary U_ICU_ENTRY_POINT_RENAME(TrieWordDictionary)
	#define TrimmedArrayProcessor U_ICU_ENTRY_POINT_RENAME(TrimmedArrayProcesso r)		#define TrimmedArrayProcessor U_ICU_ENTRY_POINT_RENAME(TrimmedArrayProcesso r)
	#define UCharCharacterIterator U_ICU_ENTRY_POINT_RENAME(UCharCharacterItera tor)		#define UCharCharacterIterator U_ICU_ENTRY_POINT_RENAME(UCharCharacterItera tor)
	#define UCollationPCE U_ICU_ENTRY_POINT_RENAME(UCollationPCE)		#define UCollationPCE U_ICU_ENTRY_POINT_RENAME(UCollationPCE)
			#define UDataPathIterator U_ICU_ENTRY_POINT_RENAME(UDataPathIterator)
	#define ULocRuns U_ICU_ENTRY_POINT_RENAME(ULocRuns)		#define ULocRuns U_ICU_ENTRY_POINT_RENAME(ULocRuns)
	#define UMemory U_ICU_ENTRY_POINT_RENAME(UMemory)		#define UMemory U_ICU_ENTRY_POINT_RENAME(UMemory)
	#define UObject U_ICU_ENTRY_POINT_RENAME(UObject)		#define UObject U_ICU_ENTRY_POINT_RENAME(UObject)
	#define UStack U_ICU_ENTRY_POINT_RENAME(UStack)		#define UStack U_ICU_ENTRY_POINT_RENAME(UStack)
	#define UStringEnumeration U_ICU_ENTRY_POINT_RENAME(UStringEnumeration)		#define UStringEnumeration U_ICU_ENTRY_POINT_RENAME(UStringEnumeration)
			#define UTS46 U_ICU_ENTRY_POINT_RENAME(UTS46)
	#define UTrie2Singleton U_ICU_ENTRY_POINT_RENAME(UTrie2Singleton)		#define UTrie2Singleton U_ICU_ENTRY_POINT_RENAME(UTrie2Singleton)
	#define UVector U_ICU_ENTRY_POINT_RENAME(UVector)		#define UVector U_ICU_ENTRY_POINT_RENAME(UVector)
	#define UVector32 U_ICU_ENTRY_POINT_RENAME(UVector32)		#define UVector32 U_ICU_ENTRY_POINT_RENAME(UVector32)
	#define UVector64 U_ICU_ENTRY_POINT_RENAME(UVector64)		#define UVector64 U_ICU_ENTRY_POINT_RENAME(UVector64)
	#define UnescapeTransliterator U_ICU_ENTRY_POINT_RENAME(UnescapeTranslitera tor)		#define UnescapeTransliterator U_ICU_ENTRY_POINT_RENAME(UnescapeTranslitera tor)
	#define UnhandledEngine U_ICU_ENTRY_POINT_RENAME(UnhandledEngine)		#define UnhandledEngine U_ICU_ENTRY_POINT_RENAME(UnhandledEngine)
	#define UnicodeArabicOpenTypeLayoutEngine U_ICU_ENTRY_POINT_RENAME(UnicodeA rabicOpenTypeLayoutEngine)		#define UnicodeArabicOpenTypeLayoutEngine U_ICU_ENTRY_POINT_RENAME(UnicodeA rabicOpenTypeLayoutEngine)
	#define UnicodeFilter U_ICU_ENTRY_POINT_RENAME(UnicodeFilter)		#define UnicodeFilter U_ICU_ENTRY_POINT_RENAME(UnicodeFilter)
	#define UnicodeFunctor U_ICU_ENTRY_POINT_RENAME(UnicodeFunctor)		#define UnicodeFunctor U_ICU_ENTRY_POINT_RENAME(UnicodeFunctor)
	#define UnicodeMatcher U_ICU_ENTRY_POINT_RENAME(UnicodeMatcher)		#define UnicodeMatcher U_ICU_ENTRY_POINT_RENAME(UnicodeMatcher)
End of changes. 18 change blocks.
	7 lines changed or deleted		28 lines changed or added

	usystem.h		usystem.h
	skipping to change at line 35		skipping to change at line 35
	# if U_DISABLE_RENAMING		# if U_DISABLE_RENAMING
	# define u_cleanup u_cleanup_SYSTEM_API_DO_NOT_USE		# define u_cleanup u_cleanup_SYSTEM_API_DO_NOT_USE
	# define u_setAtomicIncDecFunctions u_setAtomicIncDecFunctions_SYSTE M_API_DO_NOT_USE		# define u_setAtomicIncDecFunctions u_setAtomicIncDecFunctions_SYSTE M_API_DO_NOT_USE
	# define u_setMemoryFunctions u_setMemoryFunctions_SYSTEM_API_DO_NOT _USE		# define u_setMemoryFunctions u_setMemoryFunctions_SYSTEM_API_DO_NOT _USE
	# define u_setMutexFunctions u_setMutexFunctions_SYSTEM_API_DO_NOT_U SE		# define u_setMutexFunctions u_setMutexFunctions_SYSTEM_API_DO_NOT_U SE
	# define ucnv_setDefaultName ucnv_setDefaultName_SYSTEM_API_DO_NOT_U SE		# define ucnv_setDefaultName ucnv_setDefaultName_SYSTEM_API_DO_NOT_U SE
	# define uloc_getDefault uloc_getDefault_SYSTEM_API_DO_NOT_USE		# define uloc_getDefault uloc_getDefault_SYSTEM_API_DO_NOT_USE
	# define uloc_setDefault uloc_setDefault_SYSTEM_API_DO_NOT_USE		# define uloc_setDefault uloc_setDefault_SYSTEM_API_DO_NOT_USE
	# else		# else
	# define u_cleanup_4_4 u_cleanup_SYSTEM_API_DO_NOT_USE		# define u_cleanup_4_5 u_cleanup_SYSTEM_API_DO_NOT_USE
	# define u_setAtomicIncDecFunctions_4_4 u_setAtomicIncDecFunctions_S		# define u_setAtomicIncDecFunctions_4_5 u_setAtomicIncDecFunctions_S
	YSTEM_API_DO_NOT_USE		YSTEM_API_DO_NOT_USE
	# define u_setMemoryFunctions_4_4 u_setMemoryFunctions_SYSTEM_API_DO		# define u_setMemoryFunctions_4_5 u_setMemoryFunctions_SYSTEM_API_DO
	_NOT_USE		_NOT_USE
	# define u_setMutexFunctions_4_4 u_setMutexFunctions_SYSTEM_API_DO_N		# define u_setMutexFunctions_4_5 u_setMutexFunctions_SYSTEM_API_DO_N
	OT_USE		OT_USE
	# define ucnv_setDefaultName_4_4 ucnv_setDefaultName_SYSTEM_API_DO_N		# define ucnv_setDefaultName_4_5 ucnv_setDefaultName_SYSTEM_API_DO_N
	OT_USE		OT_USE
	# define uloc_getDefault_4_4 uloc_getDefault_SYSTEM_API_DO_NOT_USE		# define uloc_getDefault_4_5 uloc_getDefault_SYSTEM_API_DO_NOT_USE
	# define uloc_setDefault_4_4 uloc_setDefault_SYSTEM_API_DO_NOT_USE		# define uloc_setDefault_4_5 uloc_setDefault_SYSTEM_API_DO_NOT_USE
	# endif /* U_DISABLE_RENAMING */		# endif /* U_DISABLE_RENAMING */
	#endif /* U_HIDE_SYSTEM_API */		#endif /* U_HIDE_SYSTEM_API */
	#endif /* USYSTEM_H */		#endif /* USYSTEM_H */
End of changes. 1 change blocks.
	11 lines changed or deleted		11 lines changed or added

	uvernum.h		uvernum.h
	skipping to change at line 57		skipping to change at line 57
	/** The current ICU major version as an integer.		/** The current ICU major version as an integer.
	* This value will change in the subsequent releases of ICU		* This value will change in the subsequent releases of ICU
	* @stable ICU 2.4		* @stable ICU 2.4
	*/		*/
	#define U_ICU_VERSION_MAJOR_NUM 4		#define U_ICU_VERSION_MAJOR_NUM 4
	/** The current ICU minor version as an integer.		/** The current ICU minor version as an integer.
	* This value will change in the subsequent releases of ICU		* This value will change in the subsequent releases of ICU
	* @stable ICU 2.6		* @stable ICU 2.6
	*/		*/
	#define U_ICU_VERSION_MINOR_NUM 4		#define U_ICU_VERSION_MINOR_NUM 5
	/** The current ICU patchlevel version as an integer.		/** The current ICU patchlevel version as an integer.
	* This value will change in the subsequent releases of ICU		* This value will change in the subsequent releases of ICU
	* @stable ICU 2.4		* @stable ICU 2.4
	*/		*/
	#define U_ICU_VERSION_PATCHLEVEL_NUM 1		#define U_ICU_VERSION_PATCHLEVEL_NUM 1
	/** The current ICU build level version as an integer.		/** The current ICU build level version as an integer.
	* This value is for use by ICU clients. It defaults to 0.		* This value is for use by ICU clients. It defaults to 0.
	* @stable ICU 4.0		* @stable ICU 4.0
	*/		*/
	#ifndef U_ICU_VERSION_BUILDLEVEL_NUM		#ifndef U_ICU_VERSION_BUILDLEVEL_NUM
	#define U_ICU_VERSION_BUILDLEVEL_NUM 0		#define U_ICU_VERSION_BUILDLEVEL_NUM 0
	#endif		#endif
	/** Glued version suffix for renamers		/** Glued version suffix for renamers
	* This value will change in the subsequent releases of ICU		* This value will change in the subsequent releases of ICU
	* @stable ICU 2.6		* @stable ICU 2.6
	*/		*/
	#define U_ICU_VERSION_SUFFIX _44		#define U_ICU_VERSION_SUFFIX _45
	/** Glued version suffix function for renamers		/** Glued version suffix function for renamers
	* This value will change in the subsequent releases of ICU.		* This value will change in the subsequent releases of ICU.
	* If a custom suffix (such as matching library suffixes) is desired, this can be modified.		* If a custom suffix (such as matching library suffixes) is desired, this can be modified.
	* Note that if present, platform.h may contain an earlier definition of t his macro.		* Note that if present, platform.h may contain an earlier definition of t his macro.
	* @draft ICU 4.2		* @draft ICU 4.2
	*/		*/
	#ifndef U_ICU_ENTRY_POINT_RENAME		#ifndef U_ICU_ENTRY_POINT_RENAME
	#define U_ICU_ENTRY_POINT_RENAME(x) x ## _44		#define U_ICU_ENTRY_POINT_RENAME(x) x ## _45
	#endif		#endif
	/** The current ICU library version as a dotted-decimal string. The patchle vel		/** The current ICU library version as a dotted-decimal string. The patchle vel
	* only appears in this string if it non-zero.		* only appears in this string if it non-zero.
	* This value will change in the subsequent releases of ICU		* This value will change in the subsequent releases of ICU
	* @stable ICU 2.4		* @stable ICU 2.4
	*/		*/
	#define U_ICU_VERSION "4.4.1"		#define U_ICU_VERSION "4.5.1"
	/** The current ICU library major/minor version as a string without dots, f or library name suffixes.		/** The current ICU library major/minor version as a string without dots, f or library name suffixes.
	* This value will change in the subsequent releases of ICU		* This value will change in the subsequent releases of ICU
	* @stable ICU 2.6		* @stable ICU 2.6
	*/		*/
	#define U_ICU_VERSION_SHORT "44"		#define U_ICU_VERSION_SHORT "45"
	/** Data version in ICU4C.		/** Data version in ICU4C.
	* @internal ICU 4.4 Internal Use Only		* @internal ICU 4.4 Internal Use Only
	**/		**/
	#define U_ICU_DATA_VERSION "4.4.0.1"		#define U_ICU_DATA_VERSION "4.4"
	/*========================================================================= ==		/*========================================================================= ==
	* ICU collation framework version information		* ICU collation framework version information
	* Version info that can be obtained from a collator is affected by these		* Version info that can be obtained from a collator is affected by these
	* numbers in a secret and magic way. Please use collator version as whole		* numbers in a secret and magic way. Please use collator version as whole
	*========================================================================= ==		*========================================================================= ==
	*/		*/
	/** Collation runtime version (sort key generator, strcoll).		/** Collation runtime version (sort key generator, strcoll).
	* If the version is different, sortkeys for the same string could be diffe rent		* If the version is different, sortkeys for the same string could be diffe rent
End of changes. 6 change blocks.
	6 lines changed or deleted		6 lines changed or added

This html diff was produced by rfcdiff 1.41. The latest version is available from http://tools.ietf.org/tools/rfcdiff/