organicmaps/icu
13
Fork 0
mirror of https://github.com/unicode-org/icu.git synced 2025-04-06 22:15:31 +00:00
Code Issues 1 Projects Releases Wiki Activity Actions 1

ICU-184 resource data files in memory mapped format (initial revision)

Browse source 
X-SVN-Rev: 1365
This commit is contained in:
Vladimir Weinstein 2000-05-15 18:39:17 +00:00
parent dcf806ca7a
commit c786b21d52
52 changed files with 5533 additions and 2011 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
icu4c/source/common/Makefile.in
View file

@ -73,10 +73,12 @@ cpputils.o cstring.o dcmpdata.o digitlst.o filestrm.o locid.o locmap.o \
mutex.o normlzr.o putil.o rbcache.o resbund.o schriter.o scsu.o \
uchar.o uchriter.o ucmp8.o ucmp16.o ucmp32.o ucnv.o ucnv_bld.o \
ucnv_cnv.o ucnv_err.o ucnv_io.o uhash.o uhash_us.o uloc.o unicode.o unistr.o \
ures.o ustring.o rbread.o rbdata.o ubidi.o ubidiln.o \
uresbund.o uresdata.o ustring.o rbread.o rbdata.o ubidi.o ubidiln.o \
bidi.o uvector.o udata.o unames.o utf_impl.o \
ucnv2022.o ucnvlat1.o ucnv_utf.o ucnvsbcs.o ucnvmbcs.o ucnv_lmb.o
##ures.o ustring.o rbread.o rbdata.o ubidi.o ubidiln.o \
DEPS = $(OBJECTS:.o=.d)
## Header files to install

26
icu4c/source/common/common.dsp
View file

@ -81,6 +81,7 @@ BSC32=bscmake.exe
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /dll /debug /machine:I386 /pdbtype:sept
# ADD LINK32 kernel32.lib user32.lib advapi32.lib shell32.lib /nologo /base:"0x4a800000" /dll /debug /machine:I386 /out:"..\..\bin\Debug/icuuc.dll" /pdbtype:sept
# SUBTRACT LINK32 /profile
!ENDIF
@ -360,7 +361,17 @@ SOURCE=.\ucnvsbcs.c
# Begin Source File
SOURCE=.\udata.c
!IF "$(CFG)" == "common - Win32 Release"
# ADD CPP /Ze
!ELSEIF "$(CFG)" == "common - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
@ -411,16 +422,7 @@ SOURCE=.\unistr.cpp
# End Source File
# Begin Source File
SOURCE=.\ures.cpp
!IF "$(CFG)" == "common - Win32 Release"
!ELSEIF "$(CFG)" == "common - Win32 Debug"
# ADD CPP /Ze
!ENDIF
SOURCE=.\uresbund.c
# End Source File
# Begin Source File
@ -1192,6 +1194,10 @@ SOURCE=.\uresdata.h
# End Source File
# Begin Source File
SOURCE=.\uresimp.h
# End Source File
# Begin Source File
SOURCE=.\unicode\ustring.h
!IF "$(CFG)" == "common - Win32 Release"

31
icu4c/source/common/locid.cpp
View file

@ -34,6 +34,7 @@
#include "unicode/locid.h"
#include "unicode/uloc.h"
#include "unicode/resbund.h"
#include "uresimp.h"
#include "mutex.h"
#include "unicode/unicode.h"
#include "cmemory.h"
@ -677,15 +678,27 @@ const Locale*
Locale::getAvailableLocales(int32_t& count)
{
// for now, there is a hardcoded list, so just walk through that list and set it up.
if (localeList == 0)
{
count = uloc_countAvailable();
Locale *newLocaleList = new Locale[count];
for(int32_t i = 0; i < count; i++)
newLocaleList[i].setFromPOSIXID(uloc_getAvailable(i));
if (localeList == 0) {
UErrorCode status = U_ZERO_ERROR;
ResourceBundle index(UnicodeString(""), Locale(kIndexLocaleName), status);
ResourceBundle locales = index.get(kIndexTag, status);
char name[96];
locales.resetIterator();
count = locales.getSize();
Locale *newLocaleList = new Locale[count];
int32_t i = 0;
UnicodeString temp;
while(locales.hasNext()) {
temp = locales.getNextString(status);
temp.extract(0, temp.length(), name);
name[temp.length()] = '\0';
newLocaleList[i++].setFromPOSIXID(name);
}
Mutex mutex;
if(localeList != 0) {
delete []newLocaleList;

7
icu4c/source/common/putil.c
View file

@ -1038,7 +1038,11 @@ findLibraryPath(char *path, int size) {
}
/* define a path for fallbacks */
#ifdef WIN32
#define FALLBACK_PATH U_FILE_SEP_STRING ".." U_FILE_SEP_STRING "data"
#else
#define FALLBACK_PATH U_FILE_SEP_STRING "share" U_FILE_SEP_STRING "icu" U_FILE_SEP_STRING U_ICU_VERSION U_FILE_SEP_STRING
#endif
/* #include <stdio.h> */
/* #include <unistd.h> */
@ -1645,7 +1649,8 @@ _uErrorName[U_ERROR_LIMIT]={
"U_INVALID_TABLE_FORMAT",
"U_INVALID_TABLE_FILE",
"U_BUFFER_OVERFLOW_ERROR",
"U_UNSUPPORTED_ERROR"
"U_UNSUPPORTED_ERROR",
"U_RESOURCE_TYPE_MISMATCH"
};
U_CAPI const char * U_EXPORT2

1
icu4c/source/common/rbdata.h
View file

@ -33,6 +33,7 @@ class ResourceBundleData
public:
virtual ~ResourceBundleData() {}
virtual UClassID getDynamicClassID(void) const = 0;
UErrorCode fCreationStatus;
};
/** Concrete data class representing a list of strings. */

1463
icu4c/source/common/resbund.cpp
View file

File diff suppressed because it is too large Load diff

8
icu4c/source/common/ucnv.c
View file

@ -273,16 +273,14 @@ int32_t ucnv_getDisplayName (const UConverter * converter,
/*create an RB, init the fill-in string, gets it from the RB */
rb = ures_open (NULL, displayLocale, err);
stringToWrite = ures_get (rb,
stringToWrite = ures_getStringByKey(rb,
converter->sharedData->staticData->name,
&stringToWriteLength,
err);
if (rb)
ures_close (rb);
if (U_SUCCESS (*err))
stringToWriteLength = u_strlen (stringToWrite);
else
if(U_FAILURE(*err))
{
/*Error While creating or getting resource from the resource bundle
*use the internal name instead

91
icu4c/source/common/uloc.c
View file

@ -22,7 +22,7 @@
#include "unicode/uloc.h"
#include "unicode/utypes.h"
#include "unicode/ures.h"
#include "uresimp.h"
#include "unicode/uchar.h"
#include "umutex.h"
#include "cstring.h"
@ -497,14 +497,15 @@ uint32_t uloc_getLCID(const char* localeID)
UErrorCode err = U_ZERO_ERROR;
char temp[30];
const UChar* lcid = NULL;
int32_t lcidLen = 0;
uint32_t result = 0;
UResourceBundle* bundle = ures_open(u_getDataDirectory(), localeID, &err);
UResourceBundle* bundle = ures_open(NULL, localeID, &err);
if (U_SUCCESS(err))
{
lcid = ures_get(bundle, _kLocaleID, &err);
lcid = ures_getStringByKey(bundle, _kLocaleID, &lcidLen, &err);
ures_close(bundle);
if (U_FAILURE(err) || !lcid || u_strlen(lcid) == 0)
if (U_FAILURE(err) || !lcid || lcidLen == 0)
{
return 0;
}
@ -530,7 +531,6 @@ int32_t uloc_getDisplayLanguage(const char* locale,
UResourceBundle* bundle;
const UChar* temp = NULL;
bool_t isDefaultLocale = FALSE;
const char* dataDir = u_getDataDirectory();
bool_t done = FALSE;
if (U_FAILURE(*status)) return 0;
@ -579,7 +579,7 @@ int32_t uloc_getDisplayLanguage(const char* locale,
}
bundle = ures_open(dataDir, inLocale, &err);
bundle = ures_open(NULL, inLocale, &err);
if (U_SUCCESS(err))
{
@ -654,7 +654,6 @@ int32_t uloc_getDisplayCountry(const char* locale,
UResourceBundle* bundle = NULL;
char inLocaleBuffer[TEMPBUFSIZE];
bool_t isDefaultLocale = FALSE;
const char* dataDir = u_getDataDirectory();
bool_t done = FALSE;
if (U_FAILURE(*status)) return 0;
@ -703,7 +702,7 @@ int32_t uloc_getDisplayCountry(const char* locale,
}
bundle = ures_open(dataDir, inLocale, &err);
bundle = ures_open(NULL, inLocale, &err);
if (U_SUCCESS(err))
{
@ -777,7 +776,6 @@ int32_t uloc_getDisplayVariant(const char* locale,
bool_t isDefaultLocale = FALSE;
char inVariantTagBuffer[TEMPBUFSIZE+2];
char* inVariantTag = inVariantTagBuffer;
const char* dataDir = u_getDataDirectory();
bool_t done = FALSE;
if (U_FAILURE(*status)) return 0;
@ -839,7 +837,7 @@ int32_t uloc_getDisplayVariant(const char* locale,
}
bundle = ures_open(dataDir, inLocale, &err);
bundle = ures_open(NULL, inLocale, &err);
if (U_SUCCESS(err))
{
@ -1006,15 +1004,6 @@ int32_t uloc_getDisplayName(const char* locale,
return i;
}
/**
* Returns a list of all available locales. The return value is a pointer to
* an array of pointers to ULocale objects. Both this array and the pointers
* it contains are owned by ICU and should not be deleted or written through
* by the caller. The array is terminated by a null pointer. RTG
*/
U_CAPI UnicodeString** T_ResourceBundle_listInstalledLocales(const char* path, int32_t* numInstalledLocales);
const char*
uloc_getAvailable(int32_t offset)
{
@ -1035,41 +1024,47 @@ int32_t uloc_countAvailable()
void _lazyEvaluate_installedLocales()
{
UnicodeString** temp;
char ** temp2;
int i;
int32_t strSize;
if (_installedLocales == NULL)
{
temp = T_ResourceBundle_listInstalledLocales(u_getDataDirectory(),
&_installedLocalesCount);
temp2 = (char **) uprv_malloc(sizeof(char*) * (_installedLocalesCount+1));
for (i = 0; i < _installedLocalesCount; i++)
{
strSize = T_UnicodeString_length(temp[i]);
temp2[i] = (char*) uprv_malloc(sizeof(char) *
(strSize + 1));
UResourceBundle *index = NULL;
UResourceBundle installed;
UErrorCode status = U_ZERO_ERROR;
const UChar *lname;
char ** temp;
int32_t i = 0;
int32_t len = 0;
T_UnicodeString_extract(temp[i], temp2[i]);
temp2[i][strSize] = 0; /* Terminate the string */
}
{
umtx_lock(NULL);
if (_installedLocales == NULL)
{
_installedLocales = temp2;
temp2 = NULL;
index = ures_open(NULL, kIndexLocaleName, &status);
ures_getByKey(index, kIndexTag, &installed, &status);
if(U_SUCCESS(status)) {
_installedLocalesCount = ures_getSize(&installed);
temp = (char **) uprv_malloc(sizeof(char*) * (_installedLocalesCount+1));
ures_resetIterator(&installed);
while(ures_hasNext(&installed)) {
lname = ures_getNextString(&installed, &len, NULL, &status);
temp[i] = (char*) uprv_malloc(sizeof(char) * (len + 1));
u_UCharsToChars(lname, temp[i], len);
temp[i][len] = 0; /* Terminate the string */
i++;
}
else {
for (i = 0; i < _installedLocalesCount; i++) uprv_free(temp2[i]);
uprv_free(temp2);
}
umtx_unlock(NULL);
{
umtx_lock(NULL);
if (_installedLocales == NULL)
{
_installedLocales = temp;
temp = NULL;
} else {
for (i = 0; i < _installedLocalesCount; i++) uprv_free(temp[i]);
uprv_free(temp);
}
umtx_unlock(NULL);
}
ures_close(&installed);
}
ures_close(index);
}
/**

383
icu4c/source/common/unicode/resbund.h
View file

@ -46,14 +46,14 @@
#ifndef RESBUND_H
#define RESBUND_H
#include "unicode/ures.h"
#include "unicode/utypes.h"
#include "unicode/unistr.h"
#include "unicode/locid.h"
#include "uhash.h"
#include <wchar.h>
class RBHashtable;
class ResourceBundleData;
class ResourceBundleCache;
class VisitedFileCache;
#ifndef _FILESTRM
typedef struct _FileStream FileStream;
#endif
@ -62,21 +62,8 @@ typedef struct _FileStream FileStream;
class Locale;
class RuleBasedCollator;
class ResourceBundle;
extern int32_t T_ResourceBundle_countArrayItemsImplementation(
const ResourceBundle* resourceBundle,
const char* resourceKey,
UErrorCode& err);
extern const UnicodeString** listInstalledLocalesImplementation(
const char* path,
int32_t* numInstalledLocales);
extern void getTaggedArrayUCharsImplementation(
const ResourceBundle* bundle,
const char *resourceTag,
UChar const** itemTags,
UChar const** items,
int32_t maxItems,
int32_t& numItems,
UErrorCode& err);
//struct UHashtable;
/**
* A class representing a collection of resource information pertaining to a given
@ -199,23 +186,148 @@ public:
ResourceBundle( const wchar_t* path,
const Locale& locale,
UErrorCode& err);
ResourceBundle(const ResourceBundle &original);
ResourceBundle(UResourceBundle *res);
ResourceBundle& operator=(const ResourceBundle& other);
~ResourceBundle();
/**
* Returns the size of a resource. Size for scalar types is always 1, and for vector/table types is
* the number of child resources.
*
* @return number of resources in a given resource.
* @draft
*/
int32_t getSize(void) const;
/**
* returns a string from a string resource type
*
* @param status: fills in the outgoing error code
* could be <TT>U_MISSING_RESOURCE_ERROR</T> if the key is not found
* could be a non-failing error
* e.g.: <TT>U_USING_FALLBACK_ERROR</TT>,<TT>U_USING_DEFAULT_ERROR </TT>
* @return a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
* @draft
*/
UnicodeString getString(UErrorCode& status) const;
/**
* Checks whether the resource has another element to iterate over.
*
* @return TRUE if there are more elements, FALSE if there is no more elements
* @draft
*/
bool_t hasNext(void) const;
/**
* Resets the internal context of a resource so that iteration starts from the first element.
*
* @draft
*/
void resetIterator(void);
/**
* Returns the key associated with this resource. Not all the resources have a key - only
* those that are members of a table.
*
* @return a key associated to this resource, or NULL if it doesn't have a key
* @draft
*/
const char *getKey(void);
/**
* Returns the type of a resource. Available types are defined in enum UResType
*
* @return type of the given resource.
* @draft
*/
UResType getType(void);
/**
* Returns the next resource in a given resource or NULL if there are no more resources
*
* @param status fills in the outgoing error code
* @return ResourceBundle object.
* @draft
*/
ResourceBundle getNext(UErrorCode& status);
/**
* Returns the next string in a resource or NULL if there are no more resources
* to iterate over.
*
* @param status fills in the outgoing error code
* @return an UnicodeString object.
* @draft
*/
UnicodeString getNextString(UErrorCode& status);
/**
* Returns the next string in a resource or NULL if there are no more resources
* to iterate over.
*
* @param key fill in for key associated with this string
* @param status fills in the outgoing error code
* @return an UnicodeString object.
* @draft
*/
UnicodeString getNextString(const char ** key, UErrorCode& status);
/**
* Returns the resource in a resource at the specified index.
*
* @param index an index to the wanted resource.
* @param status fills in the outgoing error code
* @return ResourceBundle object. If there is an error, resource is invalid.
* @draft
*/
ResourceBundle get(int32_t index, UErrorCode& status) const;
/**
* Returns the string in a given resource at the specified index.
*
* @param index an index to the wanted string.
* @param status fills in the outgoing error code
* @return an UnicodeString object. If there is an error, string is bogus
* @draft
*/
UnicodeString getStringEx(int32_t index, UErrorCode& status) const;
/**
* Returns a resource in a resource that has a given key. This procedure works only with table
* resources.
*
* @param key a key associated with the wanted resource
* @param status fills in the outgoing error code.
* @return ResourceBundle object. If there is an error, resource is invalid.
* @draft
*/
ResourceBundle get(const char* key, UErrorCode& status) const;
/**
* Returns a string in a resource that has a given key. This procedure works only with table
* resources.
*
* @param key a key associated with the wanted string
* @param status fills in the outgoing error code
* @return an UnicodeString object. If there is an error, string is bogus
* @draft
*/
UnicodeString getStringEx(const char* key, UErrorCode& status) const;
/**
* Returns the contents of a string resource. Resource data is undifferentiated
* Unicode text. The resource file may contain quoted strings or escape sequences;
* these will be parsed prior to the data's return.
* [THIS FUNCTION IS DERECATED; USE THE OVERLOAD BELOW INSTEAD]
* [THIS FUNCTION IS DEPRECATED; USE THE OVERLOAD BELOW INSTEAD]
*
* @param resourceTag The resource tag of the string resource the caller wants
* @param theString Receives the actual data in the resource
* @param err Set to U_MISSING_RESOURCE_ERROR if a resource with the
* specified tag couldn't be found.
* @draft
*/
* @deprecated removed
void getString( const char *resourceTag,
UnicodeString& theString,
UErrorCode& err) const;
*/
/**
* Returns the contents of a string resource. Resource data is undifferentiated
@ -226,8 +338,8 @@ public:
* @param err Set to U_MISSING_RESOURCE_ERROR if a resource with the
* specified tag couldn't be found.
* @return A pointer to the string from the resource bundle, or NULL if there was
* an error.
* @draft
* an error.(its lifetime is that of the resource bundle.)
* @deprecated to be removed in first release in 2001
*/
const UnicodeString* getString( const char *resourceTag,
UErrorCode& err) const;
@ -248,8 +360,8 @@ public:
* specified tag couldn't be found.
* @return The resource requested, as a pointer to an array of
* UnicodeStrings. The caller does not own the storage and
* must not delete it.
* @draft
* must not delete it. (its lifetime is that of the resource bundle.)
* @deprecated to be removed in first release in 2001
*/
const UnicodeString* getStringArray( const char *resourceTag,
int32_t& numArrayItems,
@ -268,12 +380,12 @@ public:
* @param theArrayItem Receives the actual text of the desired array item.
* @param err Set to U_MISSING_RESOURCE_ERROR if a resource with the
* specified tag couldn't be found, or if the index was out of range.
* @draft
*/
* @deprecated removed
void getArrayItem( const char *resourceTag,
int32_t index,
UnicodeString& theArrayItem,
UErrorCode& err) const;
*/
/**
* Returns a single item from a string-array resource. This will return the contents
@ -286,8 +398,9 @@ public:
* wants to extract from the resource.
* @param err Set to U_MISSING_RESOURCE_ERROR if a resource with the
* specified tag couldn't be found, or if the index was out of range.
* @return A pointer to the text of the array item, or NULL is there was an error.
* @draft
* @return A pointer to the text of the array item, or NULL is there was an error.
* (its lifetime is that of the resource bundle.)
* @deprecated to be removed in first release in 2001
*/
const UnicodeString* getArrayItem( const char *resourceTag,
int32_t index,
@ -308,8 +421,9 @@ public:
* @param err Set to U_MISSING_RESOURCE_ERROR if a resource with the
* specified tag couldn't be found.
* @return The resource requested, as a UnicodeStrings**. The caller
* does not own the storage and must not delete it.
* @draft
* does not own the storage and must not delete it. (its lifetime
* is that of the resource bundle.)
* @deprecated to be removed in first release in 2001
*/
const UnicodeString** get2dArray(const char *resourceTag,
int32_t& rowCount,
@ -332,13 +446,13 @@ public:
* @param err Set to U_MISSING_RESOURCE_ERROR if a resource with the
* specified tag couldn't be found, if the resource data was in
* the wrong format, or if either index is out of bounds.
* @draft
*/
* @deprecated removed
void get2dArrayItem(const char *resourceTag,
int32_t rowIndex,
int32_t columnIndex,
UnicodeString& theArrayItem,
UErrorCode& err) const;
*/
/**
* Return a single string from a 2-dimensional array resource. If the resource does
@ -355,7 +469,8 @@ public:
* specified tag couldn't be found, if the resource data was in
* the wrong format, or if either index is out of bounds.
* @return A pointer to the text of the array item, or NULL is there was an error.
* @draft
* (its lifetime is that of the resource bundle.)
* @deprecated to be removed in first release in 2001
*/
const UnicodeString* get2dArrayItem( const char *resourceTag,
int32_t rowIndex,
@ -376,12 +491,12 @@ public:
* @param err Set to U_MISSING_RESOURCE_ERROR if a resource with the
* specified resource tag couldn't be found, or if an item
* with the specified item tag couldn't be found in the resource.
* @draft
*/
* @deprecated removed
void getTaggedArrayItem( const char *resourceTag,
const UnicodeString& itemTag,
UnicodeString& theArrayItem,
UErrorCode& err) const;
*/
/**
* Returns a single item from a tagged-array resource This will return the contents
@ -396,7 +511,8 @@ public:
* specified resource tag couldn't be found, or if an item
* with the specified item tag coldn't be found in the resource.
* @return A pointer to the text of the array item, or NULL is there was an error.
* @draft
* (its lifetime is that of the resource bundle.)
* @deprecated to be removed in first release in 2001
*/
const UnicodeString* getTaggedArrayItem( const char *resourceTag,
const UnicodeString& itemTag,
@ -423,7 +539,7 @@ public:
* items and itemTags.
* @param err Set to U_MISSING_RESOURCE_ERROR if a resource with the
* specified tag couldn't be found.
* @draft
* @deprecated to be removed in first release in 2001
*/
void getTaggedArray( const char *resourceTag,
UnicodeString*& itemTags,
@ -461,47 +577,12 @@ public:
const Locale &getLocale(void) const ;
private:
class U_COMMON_API PathInfo {
public:
PathInfo();
PathInfo(const PathInfo& source);
PathInfo(const UnicodeString& path);
PathInfo(const UnicodeString& path, const UnicodeString& suffix);
PathInfo(const wchar_t* path, const wchar_t* suffix);
~PathInfo();
UResourceBundle *resource;
void constructForLocale(const UnicodeString& path, const Locale& locale, UErrorCode& error);
void constructForLocale(const wchar_t* path, const Locale& locale, UErrorCode& error);
void initItemCache(UErrorCode& error);
PathInfo& operator=(const PathInfo& source);
bool_t fileExists(const UnicodeString& localeName) const;
UnicodeString makeCacheKey(const UnicodeString& localeName) const;
UnicodeString makeHashkey(const UnicodeString& localeName) const;
FileStream* openFile(const UnicodeString& localeName) const;
private:
static const UChar kSeparator;
UnicodeString fPrefix;
UnicodeString fSuffix;
wchar_t* fWPrefix;
wchar_t* fWSuffix;
};
private:
friend class Locale;
friend class RuleBasedCollator;
friend int32_t T_ResourceBundle_countArrayItemsImplementation(const ResourceBundle* resourceBundle,
const char* resourceKey,
UErrorCode& err) ;
friend const UnicodeString** listInstalledLocalesImplementation(const char* path,
int32_t* numInstalledLocales);
friend void getTaggedArrayUCharsImplementation(
const ResourceBundle* bundle,
const char *resourceTag,
UChar const** itemTags,
UChar const** items,
int32_t maxItems,
int32_t& numItems,
UErrorCode& err);
/**
* This constructor is used by Collation to load a resource bundle from a specific
@ -512,155 +593,15 @@ private:
const char *localeName,
UErrorCode& status);
/**
* Return a list of all installed locales. This function returns a list of the IDs
* of all locales represented in the directory specified by this ResourceBundle. It
* depends on that directory having an "Index" tagged-list item in its "index.txt"
* file; it parses that list to determine its return value (therefore, that list
* also has to be up to date). This function is static.
*
* This function is the implementation of the Locale::listInstalledLocales()
* function. It's private because the API for it real;ly belongs in Locale.
*
* @param path The path to the locale data files. The function will
* look here for "index.txt".
* @param numInstalledLocales Receives the number of installed locales, according
* to the Index resource in index.txt.
* @return A list of the installed locales, as a pointer to an
* array of UnicodeStrings. This storage is not owned by
* the caller, who must not delete it. The information
* in this list is derived from the Index resource in
* default.txt, which must be kept up to date.
*/
static const UnicodeString* listInstalledLocales(const UnicodeString& path,
int32_t& numInstalledLocales);
/**
* Retrieve a ResourceBundle from the cache. Return NULL if not found.
*/
static const UHashtable* getFromCache(const PathInfo& path,
const UnicodeString& localeName,
ResourceBundleCache* someCache);
static const UHashtable* getFromCacheWithFallback(const PathInfo& path,
const UnicodeString& desiredLocale,
UnicodeString& returnedLocale,
ResourceBundleCache* someCache,
UErrorCode& error);
/**
* Handlers which are passed to parse() have this signature.
*/
typedef void (*Handler)(const UnicodeString& localeName,
UHashtable* hashtable,
void* context,
ResourceBundleCache* someCache);
/**
* Parse a file, storing the resource data in the cache.
*/
static void parse(const PathInfo& path,
const UnicodeString& localeName,
Handler handler,
void* context,
ResourceBundleCache* someCache,
UErrorCode &error);
/**
* If the given file exists and has not been parsed, then parse it (caching the
* resultant data) and return true.
*/
static bool_t parseIfUnparsed(const PathInfo& path,
const UnicodeString& locale,
ResourceBundleCache* fCache,
VisitedFileCache* vCache,
UErrorCode& error);
const UHashtable* getHashtableForLocale(const UnicodeString& localeName,
UnicodeString& returnedLocale,
UErrorCode& err);
const UHashtable* getHashtableForLocale(const UnicodeString& desiredLocale,
UErrorCode& error);
const ResourceBundleData* getDataForTag(const char *tag,
UErrorCode& err) const;
void constructForLocale(const PathInfo& path,
const Locale& locale,
UErrorCode& error);
static void addToCache(const UnicodeString& localeName,
UHashtable* hashtable,
void* context,
ResourceBundleCache* someCache);
static void saveCollationHashtable(const UnicodeString& localeName,
UHashtable* hashtable,
void* context,
ResourceBundleCache* cache);
private:
/**
* This internal class iterates over the fallback and/or default locales. It
* progresses as follows: Specific: language+country+variant language+country
* language Default: language+country+variant language+country language Root:
*/
class LocaleFallbackIterator
{
public:
LocaleFallbackIterator(const UnicodeString& startingLocale,
const UnicodeString& root,
bool_t useDefaultLocale);
static void U_CALLCONV deleteValue(void* value);
Locale fRealLocale;
const UnicodeString& getLocale(void) const { return fLocale; }
bool_t nextLocale(UErrorCode& status);
private:
void chopLocale(void);
UnicodeString fLocale;
UnicodeString fDefaultLocale;
UnicodeString fRoot;
bool_t fUseDefaultLocale;
bool_t fTriedDefaultLocale;
bool_t fTriedRoot;
};
private:
UHashtable* fItemCache;
static const char* kDefaultSuffix;
static const int32_t kDefaultSuffixLen;
static const char* kDefaultFilename;
static const char* kDefaultLocaleName;
static const char* kIndexLocaleName;
static const char* kIndexFilename;
static const char* kIndexTag;
static const char* kDefaultMinorVersion;
static const char* kVersionSeparator;
static const char* kVersionTag;
static ResourceBundleCache* fgUserCache;
static VisitedFileCache* fgUserVisitedFiles;
ResourceBundleCache* fgCache;
VisitedFileCache* fgVisitedFiles;
/**
* Data members. The ResourceBundle object is kept lightweight by having the fData[]
* array entries be non-owned pointers. The cache (fgCache) owns the entries and
* will delete them at static destruction time.
*/
PathInfo fPath;
enum { kDataCount = 4 };
const UHashtable* fData[kDataCount]; // These aren't const if fIsDataOwned is true
bool_t fLoaded[kDataCount];
UErrorCode fDataStatus[kDataCount]; // Returns the appropriate error code for each data table.
bool_t fIsDataOwned;
Locale fRealLocale;
LocaleFallbackIterator* fLocaleIterator;
char* fVersionID;
};
#endif

191
icu4c/source/common/unicode/ures.h
View file

@ -23,8 +23,6 @@
#define URES_H
#include "unicode/utypes.h"
#include "unicode/uloc.h"
/**
@ -116,9 +114,22 @@
/** A UResourceBundle.
* For usage in C programs.
*/
typedef void* UResourceBundle;
struct UResourceBundle;
typedef struct UResourceBundle UResourceBundle;
typedef enum {
RES_STRING=0,
RES_BINARY=1,
RES_TABLE=2,
RES_INT=7,
RES_ARRAY=8,
RES_INT_VECTOR=14,
RES_RESERVED=15
} UResType;
/**
* Functions to create and destroy resource bundles.
*/
@ -186,17 +197,18 @@ U_CAPI UResourceBundle* U_EXPORT2 ures_openW(const wchar_t* path,
* could be <TT>U_MISSING_RESOURCE_ERROR</T> if the key is not found
* could be a non-failing error
* e.g.: <TT>U_USING_FALLBACK_ERROR</TT>,<TT>U_USING_DEFAULT_ERROR </TT>
* @return: a library-owned zero-terminated unicode string (its lifetime
* @return a library-owned zero-terminated unicode string (its lifetime
* is that of the resource bundle.)
* @see ures_getArrayItem
* @see ures_get2dArrayItem
* @see ures_getTaggedItem
*@draft
* @deprecated
*/
U_CAPI const UChar* U_EXPORT2 ures_get(const UResourceBundle* resourceBundle,
const char* resourceTag,
UErrorCode* status);
/**
* Returns a resource string which is part of an array, given a resource bundle
* a key to the array and the index of the desired string.
@ -213,13 +225,14 @@ U_CAPI const UChar* U_EXPORT2 ures_get(const UResourceBundle* resourceBundle,
* @see ures_get
* @see ures_get2dArrayItem
* @see ures_getTaggedItem
*@draft
* @deprecated
*/
U_CAPI const UChar* U_EXPORT2 ures_getArrayItem(const UResourceBundle* resourceBundle,
const char* resourceTag,
int32_t resourceIndex,
UErrorCode* status);
/**
* Returns a resource string which is part of a 2D array, given a resource bundle
* a key to the array and the index pair of the desired string.
@ -237,7 +250,7 @@ U_CAPI const UChar* U_EXPORT2 ures_getArrayItem(const UResourceBundle* resou
* @see ures_get
* @see ures_getArrayItem
* @see ures_getTaggedItem
*@draft
* @deprecated
*/
U_CAPI const UChar* U_EXPORT2 ures_get2dArrayItem(const UResourceBundle* resourceBundle,
@ -262,7 +275,7 @@ U_CAPI const UChar* U_EXPORT2 ures_get2dArrayItem(const UResourceBundle* resou
* @see ures_get
* @see ures_getArrayItem
* @see ures_get2dItem
*@draft
* @deprecated
*/
U_CAPI const UChar* U_EXPORT2 ures_getTaggedArrayItem(const UResourceBundle* resourceBundle,
@ -271,7 +284,6 @@ U_CAPI const UChar* U_EXPORT2 ures_getTaggedArrayItem(const UResourceBundle* r
UErrorCode* status);
/**
* Returns the number of strings/arrays in resource bundles.
*
@ -306,9 +318,10 @@ U_CAPI int32_t U_EXPORT2 ures_countArrayItems(const UResourceBundle* resourceBun
* e.g.: <TT>U_USING_FALLBACK_ERROR</TT>,<TT>U_USING_DEFAULT_ERROR </TT>
* @see ures_open
* @see ures_openW
*@draft
* @draft
*/
U_CAPI void U_EXPORT2 ures_close(UResourceBundle* resourceBundle);
/**
* Return the version number associated with this ResourceBundle. This version
* number is a string of the form MAJOR.MINOR, where MAJOR is the version number of
@ -325,8 +338,9 @@ U_CAPI void U_EXPORT2 ures_close(UResourceBundle* resourceBundle);
* representing the code version, and n is the minor version number,
* representing the resource data file. The caller does not own this
* string.
*@draft
* @draft
*/
U_CAPI const char* U_EXPORT2 ures_getVersionNumber(const UResourceBundle* resourceBundle);
/**
@ -334,8 +348,159 @@ U_CAPI const char* U_EXPORT2 ures_getVersionNumber(const UResourceBundle* reso
* @param resourceBundle: resource bundle in question
* @param status: just for catching illegal arguments
* @return A Locale name
*@draft
* @draft
*/
U_CAPI const char* ures_getLocale(const UResourceBundle* resourceBundle, UErrorCode* status);
/** New API */
U_CAPI void ures_openFillIn(UResourceBundle *r, const char* path,
const char* localeID, UErrorCode* status);
/**
* returns a string from a string resource type
*
* @param resourceBundle: a string resource
* @param len: fills in the length of resulting string
* @param status: fills in the outgoing error code
* could be <TT>U_MISSING_RESOURCE_ERROR</T> if the key is not found
* could be a non-failing error
* e.g.: <TT>U_USING_FALLBACK_ERROR</TT>,<TT>U_USING_DEFAULT_ERROR </TT>
* @return a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
* @draft
*/
U_CAPI const UChar* U_EXPORT2 ures_getString(const UResourceBundle* resourceBundle, int32_t* len,
UErrorCode* status);
/**
* Returns the size of a resource. Size for scalar types is always 1, and for vector/table types is
* the number of child resources.
*
* @param resourceBundle: a resource
* @return number of resources in a given resource.
* @draft
*/
U_CAPI int32_t U_EXPORT2 ures_getSize(UResourceBundle *resourceBundle);
/**
* Returns the type of a resource. Available types are defined in enum UResType
*
* @param resourceBundle: a resource
* @return type of the given resource.
* @draft
*/
U_CAPI UResType U_EXPORT2 ures_getType(UResourceBundle *resourceBundle);
/**
* Returns the key associated with a given resource. Not all the resources have a key - only
* those that are members of a table.
*
* @param resourceBundle: a resource
* @return a key associated to this resource, or NULL if it doesn't have a key
* @draft
*/
U_CAPI const char * U_EXPORT2 ures_getKey(UResourceBundle *resB);
/* ITERATION API
This API provides means for iterating through a resource
*/
/**
* Resets the internal context of a resource so that iteration starts from the first element.
*
* @param resourceBundle: a resource
* @draft
*/
U_CAPI void U_EXPORT2 ures_resetIterator(UResourceBundle *resourceBundle);
/**
* Checks whether the given resource has another element to iterate over.
*
* @param resourceBundle a resource
* @return TRUE if there are more elements, FALSE if there is no more elements
* @draft
*/
U_CAPI bool_t U_EXPORT2 ures_hasNext(UResourceBundle *resourceBundle);
/**
* Returns the next resource in a given resource or NULL if there are no more resources
* to iterate over. Features a fill-in parameter.
*
* @param resourceBundle a resource
* @param fillIn if NULL a new UResourceBundle struct is allocated and must be deleted by the caller.
* Alternatively, you can supply a struct to be filled by this function.
* @param status fills in the outgoing error code
* @return a pointer to a UResourceBundle struct. If fill in param was NULL, caller must delete it
* @draft
*/
U_CAPI UResourceBundle* U_EXPORT2 ures_getNextResource(UResourceBundle *resourceBundle, UResourceBundle *fillIn, UErrorCode *status);
/**
* Returns the next string in a given resource or NULL if there are no more resources
* to iterate over.
*
* @param resourceBundle a resource
* @param len fill in length of the string
* @param key fill in for key associated with this string
* @param status fills in the outgoing error code
* @return a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
* @draft
*/
U_CAPI const UChar* U_EXPORT2 ures_getNextString(UResourceBundle *resourceBundle, int32_t* len, const char ** key, UErrorCode *status);
/**
* Returns the resource in a given resource at the specified index. Features a fill-in parameter.
*
* @param resourceBundle a resource
* @param indexR an index to the wanted resource.
* @param fillIn if NULL a new UResourceBundle struct is allocated and must be deleted by the caller.
* Alternatively, you can supply a struct to be filled by this function.
* @param status fills in the outgoing error code
* @return a pointer to a UResourceBundle struct. If fill in param was NULL, caller must delete it
* @draft
*/
U_CAPI UResourceBundle* U_EXPORT2 ures_getByIndex(const UResourceBundle *resourceBundle, int32_t indexR, UResourceBundle *fillIn, UErrorCode *status);
/**
* Returns the string in a given resource at the specified index.
*
* @param resourceBundle a resource
* @param indexS an index to the wanted string.
* @param len fill in length of the string
* @param status fills in the outgoing error code
* @return a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
* @draft
*/
U_CAPI const UChar* U_EXPORT2 ures_getStringByIndex(const UResourceBundle *resB, int32_t indexS, int32_t* len, UErrorCode *status);
/**
* Returns a resource in a given resource that has a given key. This procedure works only with table
* resources. Features a fill-in parameter.
*
* @param resourceBundle a resource
* @param key a key associated with the wanted resource
* @param fillIn if NULL a new UResourceBundle struct is allocated and must be deleted by the caller.
* Alternatively, you can supply a struct to be filled by this function.
* @param status fills in the outgoing error code.
* @return a pointer to a UResourceBundle struct. If fill in param was NULL, caller must delete it
* @draft
*/
U_CAPI UResourceBundle* U_EXPORT2 ures_getByKey(const UResourceBundle *resourceBundle, const char* key, UResourceBundle *fillIn, UErrorCode *status);
/**
* Returns a string in a given resource that has a given key. This procedure works only with table
* resources.
*
* @param resourceBundle a resource
* @param key a key associated with the wanted string
* @param len fill in length of the string
* @param status fills in the outgoing error code
* @return a pointer to a zero-terminated UChar array which lives in a memory mapped/DLL file.
* @draft
*/
U_CAPI const UChar* U_EXPORT2 ures_getStringByKey(const UResourceBundle *resB, const char* key, int32_t* len, UErrorCode *status);
#endif /*_URES*/
/*eof*/

1
icu4c/source/common/unicode/utypes.h
View file

@ -232,6 +232,7 @@ enum UErrorCode {
U_INVALID_TABLE_FILE = 14, /* Conversion table file not found*/
U_BUFFER_OVERFLOW_ERROR = 15, /* A result would not fit in the supplied buffer */
U_UNSUPPORTED_ERROR = 16, /* Requested operation not supported in current context */
U_RESOURCE_TYPE_MISMATCH = 17, /* an operation is requested over a resource that does not support it*/
U_ERROR_LIMIT
};

1107
icu4c/source/common/uresbund.c Normal file
View file

File diff suppressed because it is too large Load diff

261
icu4c/source/common/uresdata.c
View file

@ -16,8 +16,10 @@
#include "unicode/utypes.h"
#include "cstring.h"
#include "cmemory.h"
#include "unicode/udata.h"
#include "uresdata.h"
#include "uresimp.h"
/*
* Resource access helpers
@ -40,7 +42,7 @@
*
* Note that the type value for strings is 0, therefore
* res itself contains the offset value.
*/
*/
static const UChar nulUChar=0;
static const UChar *
@ -59,12 +61,12 @@ _res_getString(Resource *pRoot, Resource res, int32_t *pLength) {
* Array functions
*/
static Resource
_res_getArrayItem(Resource *pRoot, Resource res, int32_t index) {
_res_getArrayItem(Resource *pRoot, Resource res, int32_t indexR) {
int32_t *p=(int32_t *)RES_GET_POINTER(pRoot, res);
if(index<*p) {
return ((Resource *)(p))[1+index];
if(indexR<*p) {
return ((Resource *)(p))[1+indexR];
} else {
return RES_BOGUS; /* index>itemCount */
return RES_BOGUS; /* indexR>itemCount */
}
}
@ -79,28 +81,28 @@ _res_getArrayItem(Resource *pRoot, Resource res, int32_t index) {
* 16-bit padding words.
*/
static const char *
_res_getTableKey(Resource *pRoot, Resource res, uint16_t index) {
_res_getTableKey(const Resource *pRoot, const Resource res, uint16_t indexS) {
uint16_t *p=(uint16_t *)RES_GET_POINTER(pRoot, res);
if(index<*p) {
return RES_GET_KEY(pRoot, p[index+1]);
if(indexS<*p) {
return RES_GET_KEY(pRoot, p[indexS+1]);
} else {
return NULL; /* index>itemCount */
return NULL; /* indexS>itemCount */
}
}
static Resource
_res_getTableItem(Resource *pRoot, Resource res, uint16_t index) {
_res_getTableItem(const Resource *pRoot, const Resource res, uint16_t indexR) {
uint16_t *p=(uint16_t *)RES_GET_POINTER(pRoot, res);
uint16_t count=*p;
if(index<count) {
return ((Resource *)(p+1+count+(~count&1)))[index];
if(indexR<count) {
return ((Resource *)(p+1+count+(~count&1)))[indexR];
} else {
return RES_BOGUS; /* index>itemCount */
return RES_BOGUS; /* indexR>itemCount */
}
}
static Resource
_res_findTableItem(Resource *pRoot, Resource res, const char *key) {
_res_findTableItem(const Resource *pRoot, const Resource res, const char *key) {
uint16_t *p=(uint16_t *)RES_GET_POINTER(pRoot, res);
uint16_t i, start, limit;
@ -126,6 +128,47 @@ _res_findTableItem(Resource *pRoot, Resource res, const char *key) {
}
}
static uint16_t
_res_findTableIndex(const Resource *pRoot, const Resource res, const char *key) {
uint16_t *p=(uint16_t *)RES_GET_POINTER(pRoot, res);
uint16_t i, start, limit;
limit=*p++; /* number of entries */
/* do a binary search for the key */
start=0;
while(start<limit-1) {
i=(start+limit)/2;
if(uprv_strcmp(key, RES_GET_KEY(pRoot, p[i]))<0) {
limit=i;
} else {
start=i;
}
}
/* did we really find it? */
if(uprv_strcmp(key, RES_GET_KEY(pRoot, p[start]))==0) {
limit=*(p-1); /* itemCount */
return start;
} else {
return -1; /* not found */
}
}
static bool_t
_res_isStringArray(Resource *r) {
int32_t count=*(int32_t *)r;
/* check to make sure all items are strings */
while(count>0) {
if(RES_GET_TYPE(*++r)!=RES_STRING) {
return FALSE;
}
--count;
}
return TRUE;
}
/* helper for res_load() ---------------------------------------------------- */
static bool_t
@ -166,7 +209,7 @@ res_load(ResourceData *pResData,
/* currently, we accept only resources that have a Table as their roots */
if(RES_GET_TYPE(pResData->rootRes)!=RES_TABLE) {
udata_close(pResData->data);
pResData->data=NULL;
pResData->data=NULL;
return FALSE;
}
@ -182,8 +225,9 @@ res_unload(ResourceData *pResData) {
}
U_CFUNC const UChar *
res_getString(ResourceData *pResData, const char *key, int32_t *pLength) {
Resource res=_res_findTableItem(pResData->pRoot, pResData->rootRes, key);
/*res_getString(const ResourceData *pResData, const char *key, int32_t *pLength) {
Resource res=_res_findTableItem(pResData->pRoot, pResData->rootRes, key);*/
res_getString(const ResourceData *pResData, const Resource res, int32_t *pLength) {
if(res!=RES_BOGUS && RES_GET_TYPE(res)==RES_STRING) {
return _res_getString(pResData->pRoot, res, pLength);
} else {
@ -193,7 +237,7 @@ res_getString(ResourceData *pResData, const char *key, int32_t *pLength) {
}
U_CFUNC Resource
res_getStringArray(ResourceData *pResData, const char *key, int32_t *pCount) {
res_getStringArray(const ResourceData *pResData, const char *key, int32_t *pCount) {
Resource res=_res_findTableItem(pResData->pRoot, pResData->rootRes, key);
if(res!=RES_BOGUS && RES_GET_TYPE(res)==RES_ARRAY) {
Resource *p=RES_GET_POINTER(pResData->pRoot, res);
@ -201,12 +245,9 @@ res_getStringArray(ResourceData *pResData, const char *key, int32_t *pCount) {
*pCount=count;
/* check to make sure all items are strings */
while(count>0) {
if(RES_GET_TYPE(*++p)!=RES_STRING) {
if(!_res_isStringArray(p)) {
*pCount=0;
return RES_BOGUS;
}
--count;
}
return res;
} else {
@ -215,10 +256,180 @@ res_getStringArray(ResourceData *pResData, const char *key, int32_t *pCount) {
}
}
U_CFUNC int32_t
res_countArrayItems(const ResourceData *pResData, const Resource res) {
/*Resource res=_res_findTableItem(pResData->pRoot, pResData->rootRes, key);*/
if(res!=RES_BOGUS) {
if(RES_GET_TYPE(res)==RES_STRING) {
return 1;
} else if(RES_GET_TYPE(res)==RES_ARRAY) {
Resource *p=RES_GET_POINTER(pResData->pRoot, res);
int32_t count=*(int32_t *)p;
return count;
} else if(RES_GET_TYPE(res)==RES_TABLE) {
return res_getTableSize(pResData, res);
}
}
return 0;
}
U_CFUNC int32_t
res_count2dArrayCols(const ResourceData *pResData, const Resource res) {
/*Resource res=_res_findTableItem(pResData->pRoot, pResData->rootRes, key);*/
if(res!=RES_BOGUS) {
if(RES_GET_TYPE(res)==RES_ARRAY) {
Resource *p=RES_GET_POINTER(pResData->pRoot, res);
int32_t count = *(int32_t *)RES_GET_POINTER(pResData->pRoot, *(p+1)); /*Number of columns in the first row*/
return count;
}
}
return 0;
}
U_CFUNC Resource
res_get2DStringArray(const ResourceData *pResData, const char *key, int32_t *pRows, int32_t *pCols) {
Resource res=_res_findTableItem(pResData->pRoot, pResData->rootRes, key);
if(res!=RES_BOGUS && RES_GET_TYPE(res)==RES_ARRAY) {
Resource *p=RES_GET_POINTER(pResData->pRoot, res);
Resource *row=NULL;
int32_t row_count=*(int32_t *)p;
*pRows = row_count;
*pCols = *(int32_t *)RES_GET_POINTER(pResData->pRoot, *(p+1)); /*Number of columns in the first row*/
/* check to make sure all items are strings */
while(row_count>0) {
row = RES_GET_POINTER(pResData->pRoot, *(++p));
if(!_res_isStringArray(row) || RES_GET_TYPE(*p)!=RES_ARRAY) {
*pRows=0;
*pCols=0;
return RES_BOGUS;
} else {
int32_t col_count=*(int32_t *)(row);
if(*pCols != col_count) {
*pRows=0;
*pCols=0;
return RES_BOGUS;
}
}
--row_count;
}
return res;
} else {
*pRows=0;
*pCols=0;
return RES_BOGUS;
}
}
U_CFUNC Resource
res_getResource(const ResourceData *pResData, const char *key) {
return _res_findTableItem(pResData->pRoot, pResData->rootRes, key);
}
U_CFUNC Resource
res_getTable(const ResourceData *pResData, const char *key) {
return _res_findTableItem(pResData->pRoot, pResData->rootRes, key);
}
U_CFUNC Resource res_getArrayItem(const ResourceData *pResData, const Resource array, const int32_t indexR) {
return _res_getArrayItem(pResData->pRoot, array, indexR);
}
U_CFUNC Resource res_getTableItemByKey(const ResourceData *pResData, const Resource table, int32_t* indexR, const char* * key) {
if(key != NULL) {
*indexR = _res_findTableIndex(pResData->pRoot, table, *key);
if(*indexR > -1) {
*key = _res_getTableKey(pResData->pRoot, table, (uint16_t)*indexR);
return _res_getTableItem(pResData->pRoot, table, (uint16_t)*indexR);
} else {
return RES_BOGUS;
}
/*return _res_findTableItem(pResData->pRoot, table, key);*/
} else {
return RES_BOGUS;
}
}
U_CFUNC Resource res_getTableItemByIndex(const ResourceData *pResData, const Resource table, int32_t indexR, const char * * key) {
if(indexR>-1) {
if(key != NULL) {
*key = _res_getTableKey(pResData->pRoot, table, (uint16_t)indexR);
}
return _res_getTableItem(pResData->pRoot, table, (uint16_t)indexR);
} else {
return RES_BOGUS;
}
}
U_CFUNC int32_t res_getTableSize(const ResourceData *pResData, Resource table) {
uint16_t *p=(uint16_t *)RES_GET_POINTER(pResData->pRoot, table);
return *p;
}
U_CFUNC void
res_getNextStringTableItem(const ResourceData *pResData, Resource table, const UChar **value, const char **key, int32_t *len, int16_t *indexS) {
Resource next;
if(*indexS == -1) {
*indexS = 0;
}
next = _res_getTableItem(pResData->pRoot, table, *indexS);
if ((next == RES_BOGUS) || (RES_GET_TYPE(next) != RES_STRING)) {
*key = NULL;
*value = NULL;
len = 0;
return;
}
*key = _res_getTableKey(pResData->pRoot, table, *indexS);
(*indexS)++;
*value = _res_getString(pResData->pRoot, next, len);
}
U_CFUNC const UChar *
res_getStringArrayItem(ResourceData *pResData,
Resource arrayRes, int32_t index, int32_t *pLength) {
res_getStringTableItem(const ResourceData *pResData, Resource table, const char *key, int32_t *len) {
Resource res = _res_findTableItem(pResData->pRoot, table, key);
if(RES_GET_TYPE(res) != RES_STRING) {
return NULL;
}
return _res_getString(pResData->pRoot, res, len);
}
U_CFUNC const UChar *
res_get2DStringArrayItem(const ResourceData *pResData,
Resource arrayRes, int32_t row, int32_t col, int32_t *pLength) {
Resource res = _res_getArrayItem(pResData->pRoot, arrayRes, row);
return _res_getString(pResData->pRoot,
_res_getArrayItem(pResData->pRoot, arrayRes, index),
_res_getArrayItem(pResData->pRoot, res, col),
pLength);
}
U_CFUNC const UChar *
res_getStringArrayItem(const ResourceData *pResData,
Resource arrayRes, int32_t indexS, int32_t *pLength) {
return _res_getString(pResData->pRoot,
_res_getArrayItem(pResData->pRoot, arrayRes, indexS),
pLength);
}
U_CFUNC const char *
res_getVersion(const ResourceData *pResData) {
UDataInfo *info;
info = uprv_malloc(sizeof(UDataInfo));
uprv_memset(info, 0, sizeof(UDataInfo));
if(info == NULL) {
return NULL;
}
udata_getInfo(pResData->data, info);
uprv_free(info);
return NULL;
}

67
icu4c/source/common/uresdata.h
View file

@ -44,26 +44,17 @@ typedef uint32_t Resource;
*
* 0 Unicode String: int32_t length, UChar[length], (UChar)0, (padding)
* or (empty string ("") if offset==0)
*
* 1 Integer Vector: int32_t length, int32_t[length]
* 2 Binary: int32_t length, uint8_t[length], (padding)
* 1 Binary: int32_t length, uint8_t[length], (padding)
* - this value should be 16-aligned -
* 2 Table: uint16_t count, uint16_t keyStringOffsets[count], (uint16_t padding), Resource[count]
*
* 7 Integer: (28-bit offset is integer value)
* 8 Array: int32_t count, Resource[count]
*
* 14 Array: int32_t count, Resource[count]
* 15 Table: uint16_t count, uint16_t keyStringOffsets[count], (uint16_t padding), Resource[count]
* 14 Integer Vector: int32_t length, int32_t[length]
* 15 Reserved: This value denotes special purpose resources and is for internal use.
*/
enum {
RES_STRING,
RES_INT_VECTOR,
RES_BINARY,
RES_INT=7,
RES_ARRAY=14,
RES_TABLE
};
/*
* Structure for a single, memory-mapped ResourceBundle.
@ -95,14 +86,25 @@ res_unload(ResourceData *pResData);
* Returns NULL if not found.
*/
U_CFUNC const UChar *
res_getString(ResourceData *pResData, const char *key, int32_t *pLength);
res_getString(const ResourceData *pResData, const Resource res, int32_t *pLength);
/*
* Get a Resource handle for an array of strings, and get the number of strings.
* Returns RES_BOGUS if not found.
*/
U_CFUNC Resource
res_getStringArray(ResourceData *pResData, const char *key, int32_t *pCount);
res_getStringArray(const ResourceData *pResData, const char *key, int32_t *pCount);
U_CFUNC Resource
res_get2DStringArray(const ResourceData *pResData, const char *key,
int32_t *pRows, int32_t *pCols);
U_CFUNC Resource
res_getTable(const ResourceData *pResData, const char *key);
U_CFUNC Resource
res_getResource(const ResourceData *pResData, const char *key);
/*
* Get a string from a string array.
@ -110,7 +112,34 @@ res_getStringArray(ResourceData *pResData, const char *key, int32_t *pCount);
* by res_getStringArray(), and that index is within bounds.
*/
U_CFUNC const UChar *
res_getStringArrayItem(ResourceData *pResData,
Resource arrayRes, int32_t index, int32_t *pLength);
res_getStringArrayItem(const ResourceData *pResData,
Resource arrayRes, int32_t indexS, int32_t *pLength);
U_CFUNC const UChar *
res_get2DStringArrayItem(const ResourceData *pResData,
Resource arrayRes, int32_t row, int32_t col, int32_t *pLength);
U_CFUNC const UChar *
res_getStringTableItem(const ResourceData *pResData, Resource table,
const char *key, int32_t *len);
U_CFUNC const char *
res_getVersion(const ResourceData *pResData);
U_CFUNC int32_t
res_countArrayItems(const ResourceData *pResData, const Resource res);
U_CFUNC int32_t
res_count2dArrayCols(const ResourceData *pResData, const Resource res);
U_CFUNC void
res_getNextStringTableItem(const ResourceData *pResData, Resource table,
const UChar **value, const char **key, int32_t *len,
int16_t *indexS);
U_CFUNC int32_t res_getTableSize(const ResourceData *pResData, Resource table);
U_CFUNC Resource res_getArrayItem(const ResourceData *pResData, const Resource array, const int32_t indexS);
U_CFUNC Resource res_getTableItemByIndex(const ResourceData *pResData, const Resource table, int32_t indexS, const char ** key);
U_CFUNC Resource res_getTableItemByKey(const ResourceData *pResData, const Resource table, int32_t *indexS, const char* * key);
#endif

91
icu4c/source/common/uresimp.h Normal file
View file

@ -0,0 +1,91 @@
#ifndef URESIMP_H
#define URESIMP_H
#include "unicode/ures.h"
#include "unicode/uloc.h"
#include "unicode/ustring.h"
#include "cmemory.h"
#include "cstring.h"
#include "uresdata.h"
#include "uhash.h"
#include "umutex.h"
#define kRootLocaleName "root"
#define kIndexLocaleName "index"
#define kIndexTag "InstalledLocales"
/*
The default minor version and the version separator must be exactly one
character long.
*/
#define kDefaultMinorVersion "0"
#define kVersionSeparator "."
#define kVersionTag "Version"
enum UResEntryType {
ENTRY_OK = 0,
ENTRY_GOTO_ROOT = 1,
ENTRY_GOTO_DEFAULT = 2,
ENTRY_INVALID = 3
};
typedef enum UResEntryType UResEntryType;
struct UResourceDataEntry;
typedef struct UResourceDataEntry UResourceDataEntry;
struct UResourceDataEntry {
char *fName; /* name of the locale for bundle - still to decide whether it is original or fallback */
char *fPath; /* path to bundle - used for distinguishing between resources with the same name */
uint32_t fCountExisting; /* how much is this resource used */
ResourceData fData; /* data for low level access */
UResourceDataEntry *fParent; /*next resource in fallback chain*/
UResEntryType fStatus;
UErrorCode fBogus;
int32_t fHashKey; /* for faster access in the hashtable */
};
struct UResourceBundle {
const char *fKey; /*tag*/
char *fVersion;
bool_t fHasFallback;
bool_t fIsTopLevel;
bool_t fIsStackObject;
UResourceDataEntry *fData; /*for low-level access*/
int32_t fIndex;
int32_t fSize;
ResourceData fResData;
Resource fRes;
};
/*U_CFUNC UResourceBundle* ures_openNoFallback(UResourceBundle *r, const char* path, const char* localeID, UErrorCode* status);*/
U_CFUNC UResourceBundle* ures_openNoFallback(const char* path, const char* localeID, UErrorCode* status);
U_CFUNC const char* ures_getRealLocale(const UResourceBundle* resourceBundle, UErrorCode* status);
/*U_CFUNC UChar** ures_listInstalledLocales(const char *path, int32_t* count);*/
U_CFUNC const ResourceData *getFallbackData(const UResourceBundle* resBundle, const char* * resTag, Resource *res, UErrorCode *status);
U_CFUNC int32_t hashBundle(const void *parm);
U_CFUNC bool_t compareBundles(const void *p1, const void *p2);
/* Candidates for export */
U_CFUNC UResourceBundle *copyResb(UResourceBundle *r, const UResourceBundle *original);
U_CFUNC void copyResbFillIn(UResourceBundle *dest, const UResourceBundle *original);
U_CFUNC const char* ures_getName(const UResourceBundle* resB);
U_CFUNC const char* ures_getPath(const UResourceBundle* resB);
U_CFUNC const char* ures_getTag(const UResourceBundle* resB);
U_CFUNC const ResourceData * ures_getResData(const UResourceBundle* resB);
/*
U_CAPI int32_t U_EXPORT2 ures_getStringArray(const UResourceBundle* resourceBundle, const char* resourceTag, const UChar** array,
int32_t maxLen, UErrorCode* err);
U_CAPI int32_t U_EXPORT2 ures_get2dStringArray(const UResourceBundle* resourceBundle, const char* resourceTag, const UChar*** matrix,
int32_t maxRows, int32_t cols, UErrorCode* err);
U_CAPI int32_t U_EXPORT2 ures_getTaggedStringArray(const UResourceBundle* resourceBundle, const char* resourceTag, const char** itemTags,
const UChar** items, int32_t maxItems,
UErrorCode* err);
*/
#endif /*URESIMP_H*/

22
icu4c/source/i18n/calendar.cpp
View file

@ -702,11 +702,13 @@ Calendar::setWeekCountData(const Locale& desiredLocale, UErrorCode& status)
// "1" // min days in week
// }
const UnicodeString *dateTimeElements;
int32_t count;
//const UnicodeString *dateTimeElements;
//int32_t count;
if (U_FAILURE(status)) return;
ResourceBundle resource(u_getDataDirectory(), desiredLocale, status);
ResourceBundle resource(NULL, desiredLocale, status);
//ResourceBundle resource(Locale::getDataDirectory(), desiredLocale, status);
//resource.open(UnicodeString(""), desiredLocale, status);
// If the resource data doesn't seem to be present at all, then use last-resort
// hard-coded data.
@ -718,16 +720,22 @@ Calendar::setWeekCountData(const Locale& desiredLocale, UErrorCode& status)
return;
}
dateTimeElements = resource.getStringArray(kDateTimeElements, count, status);
//dateTimeElements = resource.getStringArray(kDateTimeElements, count, status);
ResourceBundle dateTimeElements = resource.get(kDateTimeElements, status);
if (U_FAILURE(status)) return;
if (count != 2)
// if (count != 2)
if(dateTimeElements.getSize()!=2)
{
status = U_INVALID_FORMAT_ERROR;
return;
}
fFirstDayOfWeek = (Calendar::EDaysOfWeek)stringToDayNumber(dateTimeElements[0], status);
fMinimalDaysInFirstWeek = (uint8_t)stringToDayNumber(dateTimeElements[1], status);
//fFirstDayOfWeek = (Calendar::EDaysOfWeek)stringToDayNumber(dateTimeElements[0], status);
//fMinimalDaysInFirstWeek = (uint8_t)stringToDayNumber(dateTimeElements[1], status);
fFirstDayOfWeek = (Calendar::EDaysOfWeek)stringToDayNumber(dateTimeElements.getStringEx((int32_t)0, status), status);
fMinimalDaysInFirstWeek = (uint8_t)stringToDayNumber(dateTimeElements.getStringEx(1, status), status);
}
/**

11
icu4c/source/i18n/datefmt.cpp
View file

@ -17,10 +17,10 @@
********************************************************************************
*/
#include "unicode/resbund.h"
#include "unicode/datefmt.h"
#include "unicode/smpdtfmt.h"
#include "mutex.h"
#include "unicode/resbund.h"
// *****************************************************************************
// class DateFormat
@ -242,9 +242,12 @@ DateFormat::getAvailableLocales(int32_t& count)
for (i=0; i<localesCount; ++i)
{
UErrorCode status = U_ZERO_ERROR;
ResourceBundle resource(u_getDataDirectory(), locales[i], status);
int32_t ignoredCount;
resource.getStringArray(SimpleDateFormat::fgDateTimePatternsTag, ignoredCount, status);
/*ResourceBundle resource(Locale::getDataDirectory(), locales[i], status);*/
ResourceBundle resource(NULL, locales[i], status);
//int32_t ignoredCount;
resource.get(SimpleDateFormat::fgDateTimePatternsTag, status);
//resource.getStringArray(SimpleDateFormat::fgDateTimePatternsTag, ignoredCount, status);
if (U_SUCCESS(status))
{
temp[newLocalesCount++] = locales[i];

22
icu4c/source/i18n/dcfmtsym.cpp
View file

@ -172,7 +172,8 @@ DecimalFormatSymbols::initialize(const Locale& locale, UErrorCode& status,
{
if (U_FAILURE(status)) return;
ResourceBundle resource(u_getDataDirectory(), locale, status);
/*ResourceBundle resource(Locale::getDataDirectory(), locale, status);*/
ResourceBundle resource(NULL, locale, status);
if (U_FAILURE(status))
{
// Initializes with last resort data if necessary.
@ -184,12 +185,23 @@ DecimalFormatSymbols::initialize(const Locale& locale, UErrorCode& status,
return;
}
int32_t numberElementsLength=0;
// Gets the number element array.
const UnicodeString* numberElements = resource.getStringArray(fgNumberElements, numberElementsLength, status);
int32_t currencyElementsLength=0;
int32_t i = 0;
ResourceBundle numberElementsRes = resource.get(fgNumberElements, status);
int32_t numberElementsLength = numberElementsRes.getSize();
UnicodeString* numberElements = new UnicodeString[numberElementsLength];
for(i = 0; i<numberElementsLength; i++) {
numberElements[i] = numberElementsRes.getStringEx(i, status);
}
// Gets the currency element array.
const UnicodeString* currencyElements = resource.getStringArray(fgCurrencyElements, currencyElementsLength, status);
ResourceBundle currencyElementsRes = resource.get(fgCurrencyElements, status);
int32_t currencyElementsLength = currencyElementsRes.getSize();
UnicodeString* currencyElements = new UnicodeString[currencyElementsLength];
for(i = 0; i<currencyElementsLength; i++) {
currencyElements[i] = currencyElementsRes.getStringEx(i, status);
}
if (U_FAILURE(status)) return;
// If the array size is too small, something is wrong with the resource

9
icu4c/source/i18n/decimfmt.cpp
View file

@ -197,8 +197,13 @@ DecimalFormat::construct(UErrorCode& status,
// one specified.
if (pattern == NULL)
{
ResourceBundle resource(u_getDataDirectory(), Locale::getDefault(), status);
resource.getArrayItem(fgNumberPatterns, 0, str, status);
/*ResourceBundle resource(Locale::getDataDirectory(), Locale::getDefault(), status);*/
ResourceBundle resource(NULL, Locale::getDefault(), status);
/*resource.open("", Locale::getDefault(), status);*/
/*resource.getArrayItem(fgNumberPatterns, 0, str, status);*/
/*str = resource.getArrayStringItem(fgNumberPatterns, 0, status);*/
str = resource.get(fgNumberPatterns, status).getStringEx((int32_t)0, status);
pattern = &str;
}

93
icu4c/source/i18n/dtfmtsym.cpp
View file

@ -14,6 +14,7 @@
* Changed weekdays/short weekdays to be one-based
* 06/14/99 stephen Removed SimpleDateFormat::fgTimeZoneDataSuffix
* 11/16/99 weiv Added 'Y' and 'e' to fgPatternChars
* 03/27/00 weiv Keeping resource bundle around!
*******************************************************************************
*/
@ -160,6 +161,7 @@ DateFormatSymbols& DateFormatSymbols::operator=(const DateFormatSymbols& other)
else fZoneStrings = other.fZoneStrings;
fLocalPatternChars = other.fLocalPatternChars;
return *this;
}
@ -415,6 +417,17 @@ DateFormatSymbols::setLocalPatternChars(const UnicodeString& newLocalPatternChar
//------------------------------------------------------
void
DateFormatSymbols::initField(UnicodeString **field, int32_t& length, const ResourceBundle data, uint8_t ownfield, UErrorCode &status) {
//ResourceBundle data = source->getByKey(tag, status);
length = data.getSize();
*field = new UnicodeString[length];
for(int32_t i = 0; i<length; i++) {
*(*(field)+i) = data.getStringEx(i, status);
}
setIsOwned(ownfield, TRUE);
}
void
DateFormatSymbols::initializeData(const Locale& locale, UErrorCode& status, bool_t useLastResortData)
{
@ -427,7 +440,9 @@ DateFormatSymbols::initializeData(const Locale& locale, UErrorCode& status, bool
* We cast away const here, but that's okay; we won't delete any of
* these.
*/
ResourceBundle resource(u_getDataDirectory(), locale, status);
/*ResourceBundle resource(Locale::getDataDirectory(), locale, status);*/
ResourceBundle resource(NULL, locale, status);
/*resource.open(UnicodeString(""), locale, status);*/
if (U_FAILURE(status))
{
if (useLastResortData)
@ -466,30 +481,70 @@ DateFormatSymbols::initializeData(const Locale& locale, UErrorCode& status, bool
// if we make it to here, the resource data is cool, and we can get everything out
// of it that we need except for the time-zone and localized-pattern data, which
// are stoerd in a separate file
fEras = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgErasTag, fErasCount, status);
fMonths = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgMonthNamesTag, fMonthsCount, status);
fShortMonths = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgMonthAbbreviationsTag, fShortMonthsCount, status);
// {sfb} fixed to handle 1-based weekdays
UnicodeString *lWeekdays = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgDayNamesTag, fWeekdaysCount, status);
fWeekdays = new UnicodeString [8];
fWeekdays[0] = UnicodeString();
uprv_arrayCopy(lWeekdays, 0, fWeekdays, 1, 7);
setIsOwned(kWeekdays, TRUE);
//fWeekdays = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgDayNamesTag, fWeekdaysCount, status);
initField(&fEras, fErasCount, resource.get(SimpleDateFormat::fgErasTag, status), kEras, status);
initField(&fMonths, fMonthsCount, resource.get(SimpleDateFormat::fgMonthNamesTag, status), kMonths, status);
initField(&fShortMonths, fShortMonthsCount, resource.get(SimpleDateFormat::fgMonthAbbreviationsTag, status), kShortMonths, status);
initField(&fAmPms, fAmPmsCount, resource.get(SimpleDateFormat::fgAmPmMarkersTag, status), kAmPms, status);
fLocalPatternChars = resource.getStringEx(SimpleDateFormat::fgLocalPatternCharsTag, status);
UnicodeString *lSWeekdays = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgDayAbbreviationsTag, fShortWeekdaysCount, status);
fShortWeekdays = new UnicodeString [8];
//fEras = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgErasTag, fErasCount, status);
//fMonths = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgMonthNamesTag, fMonthsCount, status);
//fShortMonths = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgMonthAbbreviationsTag, fShortMonthsCount, status);
//fAmPms = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgAmPmMarkersTag, fAmPmsCount, status);
//fLocalPatternChars = *resource.getString(SimpleDateFormat::fgLocalPatternCharsTag, status);
ResourceBundle zoneArray = resource.get(SimpleDateFormat::fgZoneStringsTag, status);
fZoneStringsRowCount = zoneArray.getSize();
ResourceBundle zoneRow = zoneArray.get((int32_t)0, status);
fZoneStringsColCount = zoneRow.getSize();
fZoneStrings = new UnicodeString * [fZoneStringsRowCount];
for(int32_t i = 0; i<fZoneStringsRowCount; i++) {
*(fZoneStrings+i) = new UnicodeString[fZoneStringsColCount];
zoneRow = zoneArray.get(i, status);
for(int32_t j = 0; j<fZoneStringsColCount; j++) {
fZoneStrings[i][j] = zoneRow.getStringEx(j, status);
}
}
setIsOwned(kZoneStrings, TRUE);
/*
ResourceBundle data = resource.getByKey(SimpleDateFormat::fgErasTag, status);
fErasCount = data.getSize();
fEras = new UnicodeString[fErasCount];
for(int32_t i = 0; i<fErasCount; i++) {
fEras[i] = data.getStringByIndex(i, status);
}
setIsOwned(kEras, TRUE);
data = resource.getByKey(SimpleDateFormat::fgMonthNamesTag, status);
fMonthsCount = data.getSize();
fMonths = new UnicodeString[fMonthsCount];
for(int32_t i = 0; i<fMonthsCount; i++) {
fMonths[i] = data.getStringByIndex(i, status);
}
setIsOwned(kMonths, TRUE);
*/
// {sfb} fixed to handle 1-based weekdays
ResourceBundle weekdaysData = resource.get(SimpleDateFormat::fgDayNamesTag, status);
fWeekdaysCount = weekdaysData.getSize();
fWeekdays = new UnicodeString[fWeekdaysCount+1];
fWeekdays[0] = UnicodeString();
for(i = 0; i<fWeekdaysCount; i++) {
fWeekdays[i+1] = weekdaysData.getStringEx(i, status);
}
setIsOwned(kWeekdays, TRUE);
ResourceBundle lsweekdaysData = resource.get(SimpleDateFormat::fgDayAbbreviationsTag, status);
fShortWeekdaysCount = lsweekdaysData.getSize();
fShortWeekdays = new UnicodeString[fShortWeekdaysCount+1];
fShortWeekdays[0] = UnicodeString();
uprv_arrayCopy(lSWeekdays, 0, fShortWeekdays, 1, 7);
for(i = 0; i<fShortWeekdaysCount; i++) {
fShortWeekdays[i+1] = lsweekdaysData.getStringEx(i, status);
}
setIsOwned(kShortWeekdays, TRUE);
//fShortWeekdays = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgDayAbbreviationsTag, fShortWeekdaysCount, status);
fWeekdaysCount = fShortWeekdaysCount = 8;
fAmPms = (UnicodeString*)resource.getStringArray(SimpleDateFormat::fgAmPmMarkersTag, fAmPmsCount, status);
fZoneStrings = (UnicodeString**)resource.get2dArray(SimpleDateFormat::fgZoneStringsTag, fZoneStringsRowCount, fZoneStringsColCount, status);
resource.getString(SimpleDateFormat::fgLocalPatternCharsTag, fLocalPatternChars, status);
// If the locale data does not include new pattern chars, use the defaults
if (fLocalPatternChars.length() < PATTERN_CHARS_LEN) {
UnicodeString str;

432
icu4c/source/i18n/i18n.dsp
View file

@ -97,66 +97,210 @@ SOURCE=.\brkdict.cpp
# Begin Source File
SOURCE=.\brkiter.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\calendar.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\choicfmt.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\colcache.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\coleitr.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\coll.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\colrules.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\cpdtrans.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\datefmt.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\dbbi.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\dbbi_tbl.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\dcfmtsym.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\decimfmt.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\dtfmtsym.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\fmtable.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\format.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
@ -166,94 +310,301 @@ SOURCE=.\gregocal.cpp
# Begin Source File
SOURCE=.\hangjamo.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\hextouni.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\jamohang.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\mergecol.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\msgfmt.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\nultrans.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\numfmt.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\ptnentry.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\rbbi.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\rbbi_tbl.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\rbt.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\rbt_data.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\rbt_pars.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\rbt_rule.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\rbt_set.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\simpletz.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\smpdtfmt.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\sortkey.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\tables.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\tblcoll.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\tcoldata.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\timezone.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\translit.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
@ -262,22 +613,67 @@ SOURCE=.\txtbdry.cpp
# Begin Source File
SOURCE=.\ubrk.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\ucal.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\ucol.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\udat.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\umsg.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
@ -286,18 +682,54 @@ SOURCE=.\unifltlg.cpp
# Begin Source File
SOURCE=.\unirange.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\uniset.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\unitohex.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# Begin Source File
SOURCE=.\unum.cpp
!IF "$(CFG)" == "i18n - Win32 Release"
!ELSEIF "$(CFG)" == "i18n - Win32 Debug"
# ADD CPP /Ze
!ENDIF
# End Source File
# End Group
# Begin Group "Header Files"

21
icu4c/source/i18n/numfmt.cpp
View file

@ -406,7 +406,9 @@ NumberFormat::createInstance(const Locale& desiredLocale,
return NULL;
}
ResourceBundle resource(u_getDataDirectory(), desiredLocale, status);
/*ResourceBundle resource(Locale::getDataDirectory(), desiredLocale, status);*/
ResourceBundle resource(NULL, desiredLocale, status);
if (U_FAILURE(status))
{
// We don't appear to have resource data available -- use the last-resort data
@ -422,19 +424,24 @@ NumberFormat::createInstance(const Locale& desiredLocale,
return f;
}
int32_t patternCount=0;
const UnicodeString* numberPatterns = resource.getStringArray(DecimalFormat::fgNumberPatterns,
patternCount, status);
//int32_t patternCount=0;
//const UnicodeString* numberPatterns = resource.getStringArray(DecimalFormat::fgNumberPatterns,
// patternCount, status);
ResourceBundle numberPatterns = resource.get(DecimalFormat::fgNumberPatterns, status);
// If not all the styled patterns exists for the NumberFormat in this locale,
// sets the status code to failure and returns nil.
if (patternCount < fgNumberPatternsCount) status = U_INVALID_FORMAT_ERROR;
//if (patternCount < fgNumberPatternsCount) status = U_INVALID_FORMAT_ERROR;
if (numberPatterns.getSize() < fgNumberPatternsCount) status = U_INVALID_FORMAT_ERROR;
if (U_FAILURE(status)) return NULL;
// If the requested style doesn't exist, use a last-resort style.
// This is to support scientific styles before we have all the
// resource data in place.
const UnicodeString& pattern = style < patternCount ?
numberPatterns[style] : fgLastResortNumberPatterns[style];
//const UnicodeString& pattern = style < patternCount ?
// numberPatterns[style] : fgLastResortNumberPatterns[style];
const UnicodeString& pattern = style < numberPatterns.getSize()?
numberPatterns.getStringEx(style, status) : fgLastResortNumberPatterns[style];
// Loads the decimal symbols of the desired locale.
DecimalFormatSymbols* symbolsToAdopt = new DecimalFormatSymbols(desiredLocale, status);

32
icu4c/source/i18n/smpdtfmt.cpp
View file

@ -260,11 +260,15 @@ void SimpleDateFormat::construct(EStyle timeStyle,
// load up the DateTimePatters resource from the appropriate locale (throw
// an error if for some weird reason the resource is malformed)
ResourceBundle resources(u_getDataDirectory(), locale, status);
int32_t dtCount;
const UnicodeString *dateTimePatterns = resources.getStringArray(fgDateTimePatternsTag, dtCount, status);
/*ResourceBundle resources(Locale::getDataDirectory(), locale, status);*/
ResourceBundle resources(NULL, locale, status);
/*resources.open("", locale, status);*/
//int32_t dtCount;
//const UnicodeString *dateTimePatterns = resources.getStringArray(fgDateTimePatternsTag, dtCount, status);
ResourceBundle dateTimePatterns = resources.get(fgDateTimePatternsTag, status);
if (U_FAILURE(status)) return;
if (dtCount <= kDateTime)
//if (dtCount <= kDateTime)
if (dateTimePatterns.getSize() <= kDateTime)
{
status = U_INVALID_FORMAT_ERROR;
return;
@ -291,17 +295,22 @@ void SimpleDateFormat::construct(EStyle timeStyle,
// pattern = MessageFormat.format(dateTimePatterns[8], dateTimeArgs);
Formattable *timeDateArray = new Formattable[2];
timeDateArray[0].setString(dateTimePatterns[timeStyle]);
timeDateArray[1].setString(dateTimePatterns[dateStyle]);
//timeDateArray[0].setString(UnicodeString(dateTimePatterns[timeStyle]));
//timeDateArray[1].setString(UnicodeString(dateTimePatterns[dateStyle]));
timeDateArray[0].setString(dateTimePatterns.getStringEx(timeStyle, status));
timeDateArray[1].setString(dateTimePatterns.getStringEx(dateStyle, status));
MessageFormat::format(dateTimePatterns[kDateTime], timeDateArray, 2, fPattern, status);
//MessageFormat::format(UnicodeString(dateTimePatterns[kDateTime]), timeDateArray, 2, fPattern, status);
MessageFormat::format(dateTimePatterns.getStringEx(kDateTime, status), timeDateArray, 2, fPattern, status);
delete [] timeDateArray;
}
// if the pattern includes just time data or just date date, load the appropriate
// pattern string from the resources
else if (timeStyle != kNone) fPattern = dateTimePatterns[timeStyle];
else if (dateStyle != kNone) fPattern = dateTimePatterns[dateStyle];
//else if (timeStyle != kNone) fPattern = UnicodeString(dateTimePatterns[timeStyle]);
//else if (dateStyle != kNone) fPattern = UnicodeString(dateTimePatterns[dateStyle]);
else if (timeStyle != kNone) fPattern = dateTimePatterns.getStringEx(timeStyle, status);
else if (dateStyle != kNone) fPattern = dateTimePatterns.getStringEx(dateStyle, status);
// and if it includes _neither_, that's an error
else status = U_INVALID_FORMAT_ERROR;
@ -1294,10 +1303,11 @@ int32_t SimpleDateFormat::subParse(const UnicodeString& text, int32_t& start, UC
// {sfb} kludge for case-insensitive compare
UnicodeString s1(text);
s1.toLower();
UnicodeString s2;
for (; j <= 4; ++j)
{
UnicodeString s2(fSymbols->fZoneStrings[i][j]);
s2 = fSymbols->fZoneStrings[i][j];
s2.toLower();
if ((s1.compare(start, s2.length(), s2, 0, s2.length())) == 0)

54
icu4c/source/i18n/tblcoll.cpp
View file

@ -947,17 +947,19 @@ RuleBasedCollator::constructFromFile( const Locale& locale,
char *binaryFilePath = createPathName(UnicodeString(u_getDataDirectory(),""),
localeFileName, UnicodeString(kFilenameSuffix,""));
if(tryBinaryFile) {
// Try to load up the collation from a binary file first
constructFromFile(binaryFilePath, status);
#ifdef COLLDEBUG
cerr << localeFileName << kFilenameSuffix << " binary load " << u_errorName(status) << endl;
#endif
if(U_SUCCESS(status) || status == U_MEMORY_ALLOCATION_ERROR)
{
delete [] binaryFilePath;
return;
}
if(tryBinaryFile) {
// Try to load up the collation from a binary file first
constructFromFile(binaryFilePath, status);
#ifdef COLLDEBUG
cerr << localeFileName << kFilenameSuffix << " binary load " << u_errorName(status) << endl;
#endif
if(U_SUCCESS(status) || status == U_MEMORY_ALLOCATION_ERROR) {
delete [] binaryFilePath;
return;
}
if(status == U_FILE_ACCESS_ERROR) {
status = U_ZERO_ERROR;
}
}
// Now try to load it up from a resource bundle text source file
@ -966,7 +968,6 @@ RuleBasedCollator::constructFromFile( const Locale& locale,
char *ch;
ch = new char[localeFileName.size() + 1];
ch[localeFileName.extract(0, 0x7fffffff, ch, "")] = 0;
ResourceBundle bundle(dataDir, ch, status);
delete [] ch;
@ -978,21 +979,26 @@ RuleBasedCollator::constructFromFile( const Locale& locale,
return;
}
#ifdef COLLDEBUG
cerr << localeFileName << " ascii load " << u_errorName(status) << endl;
#endif
#ifdef COLLDEBUG
cerr << localeFileName << " ascii load " << u_errorName(status) << endl;
#endif
// check and see if this resource bundle contains collation data
// check and see if this resource bundle contains collation data
UnicodeString colString;
UErrorCode intStatus = U_ZERO_ERROR;
UnicodeString colString;
UErrorCode intStatus = U_ZERO_ERROR;
/* REDO */
const UnicodeString *t = bundle.getString("CollationElements", intStatus);
bundle.getString("CollationElements", colString, intStatus);
if(colString.isBogus()) {
status = U_MEMORY_ALLOCATION_ERROR;
delete [] binaryFilePath;
return;
}
if(t != NULL) {
colString = *t;
}
if(colString.isBogus()) {
status = U_MEMORY_ALLOCATION_ERROR;
delete [] binaryFilePath;
return;
}
// if this bundle doesn't contain collation data, break out
if(U_FAILURE(intStatus)) {

51
icu4c/source/i18n/translit.cpp
View file

@ -383,7 +383,9 @@ UnicodeString& Transliterator::getDisplayName(const UnicodeString& ID,
const Locale& inLocale,
UnicodeString& result) {
UErrorCode status = U_ZERO_ERROR;
ResourceBundle bundle(u_getDataDirectory(), inLocale, status);
// Suspend checking status until later...
// build the char* key
@ -394,10 +396,13 @@ UnicodeString& Transliterator::getDisplayName(const UnicodeString& ID,
// Try to retrieve a UnicodeString* from the bundle. The result,
// if any, should NOT be deleted.
const UnicodeString* resString = bundle.getString(key, status);
/*const UnicodeString* resString = bundle.getString(key, status);*/
UnicodeString resString = bundle.getStringEx(key, status);
if (U_SUCCESS(status) && resString != 0) {
return result = *resString; // [sic] assign & return
/*if (U_SUCCESS(status) && resString != 0) {*/
if (U_SUCCESS(status) && resString.length() != 0) {
/*return result = *resString; // [sic] assign & return*/
return result = resString; // [sic] assign & return
}
// We have failed to get a name from the locale data. This is
@ -407,10 +412,13 @@ UnicodeString& Transliterator::getDisplayName(const UnicodeString& ID,
// name from the ID.
status = U_ZERO_ERROR;
resString = bundle.getString(RB_DISPLAY_NAME_PATTERN, status);
/*resString = bundle.getString(RB_DISPLAY_NAME_PATTERN, status);*/
resString = bundle.getStringEx(RB_DISPLAY_NAME_PATTERN, status);
if (U_SUCCESS(status) && resString != 0) {
MessageFormat msg(*resString, inLocale, status);
/*if (U_SUCCESS(status) && resString != 0) {*/
if (U_SUCCESS(status) && resString.length() != 0) {
/*MessageFormat msg(*resString, inLocale, status);*/
MessageFormat msg(resString, inLocale, status);
// Suspend checking status until later...
// We pass either 2 or 3 Formattable objects to msg.
@ -440,10 +448,12 @@ UnicodeString& Transliterator::getDisplayName(const UnicodeString& ID,
args[j].getString(s);
key[length + s.extract(0, sizeof(key)-length-1, key+length, "")]=0;
resString = bundle.getString(key, status);
/*resString = bundle.getString(key, status);*/
resString = bundle.getStringEx(key, status);
if (U_SUCCESS(status)) {
args[j] = *resString;
/*args[j] = *resString;*/
args[j] = resString;
}
}
@ -642,20 +652,22 @@ Transliterator* Transliterator::_createInstance(const UnicodeString& ID,
// 2-d array at static init time, as a locale language. We're
// just using the locale mechanism to map through to a file
// name; this in no way represents an actual locale.
char *ch;
ch = new char[entry->rbFile.size() + 1];
ch[entry->rbFile.extract(0, 0x7fffffff, ch, "")] = 0;
Locale fakeLocale(ch);
delete [] ch;
ResourceBundle bundle(Transliterator::getDataDirectory(),
ResourceBundle bundle(NULL,
fakeLocale, status);
// Call RBT to parse the rules from the resource bundle
// We don't own the rules - 'rules' is an alias pointer to
// a string in the RB cache.
const UnicodeString* rules = bundle.getString(RB_RULE, status);
/*const UnicodeString* rules = bundle.getString(RB_RULE, status);*/
UnicodeString rules = bundle.getStringEx(RB_RULE, status);
// If rules == 0 at this point, or if the status indicates a
// failure, then we don't have any rules -- there is probably
@ -663,9 +675,15 @@ Transliterator* Transliterator::_createInstance(const UnicodeString& ID,
// correspond to all the installed transliterators; if it
// lists something that's not installed, we'll get a null
// pointer here.
if (rules != 0 && U_SUCCESS(status)) {
/* if (rules != 0 && U_SUCCESS(status)) {
data = TransliterationRuleParser::parse(*rules, isReverse
? RuleBasedTransliterator::REVERSE
: RuleBasedTransliterator::FORWARD,
parseError); */
if (rules.length() != 0 && U_SUCCESS(status)) {
data = TransliterationRuleParser::parse(rules, isReverse
? RuleBasedTransliterator::REVERSE
: RuleBasedTransliterator::FORWARD,
parseError);
@ -868,9 +886,13 @@ void Transliterator::initializeCache(void) {
* }
*/
Locale indexLoc("index");
Locale indexLoc("translit_index");
/*
ResourceBundle bundle(Transliterator::getDataDirectory(),
indexLoc, status);
*/
ResourceBundle bundle(NULL,
indexLoc, status);
int32_t rows, cols;
const UnicodeString** ruleBasedIDs =
@ -886,7 +908,7 @@ void Transliterator::initializeCache(void) {
entry->entryType = (col == 0) ?
CacheEntry::RULE_BASED_PLACEHOLDER :
CacheEntry::REVERSE_RULE_BASED_PLACEHOLDER;
entry->rbFile = row[2];
entry->rbFile = UnicodeString(row[2]);
//uhash_putKey(cache, hash(row[col]), entry, &status);
cache->put(row[col], entry, status);
@ -897,7 +919,8 @@ void Transliterator::initializeCache(void) {
* need to do is change the id vector so that it
* owns its strings and create a copy here.
*/
cacheIDs.addElement((void*) &row[col]);
/*cacheIDs.addElement((void*) &row[col]);*/
cacheIDs.addElement((void*) new UnicodeString(row[col]));
}
}
}

3
icu4c/source/i18n/unicode/dtfmtsym.h
View file

@ -20,6 +20,7 @@
#include "unicode/utypes.h"
#include "unicode/locid.h"
#include "unicode/resbund.h"
/* forward declaration */
class SimpleDateFormat;
@ -298,6 +299,8 @@ private:
static UnicodeString fgPatternChars;
private:
void initField(UnicodeString **field, int32_t& length, const ResourceBundle data, uint8_t ownfield, UErrorCode &status);
/**
* Called by the constructors to actually load data from the resources
*/

2
icu4c/source/test/cintltst/Makefile.in
View file

@ -66,7 +66,7 @@ OBJECTS = callcoll.o calltest.o capitst.o cbiapts.o cbkittst.o \
ccaltst.o ccapitst.o ccolltst.o cconvtst.o ccurrtst.o cdantst.o \
cdattst.o cdetst.o cdtdptst.o cdtrgtst.o cestst.o cfintst.o cformtst.o \
cfrtst.o cg7coll.o chashtst.o cintltst.o citertst.o cjaptst.o cloctst.o cmsgtst.o \
cnmdptst.o cnormtst.o cnumtst.o cregrtst.o crestst.o cturtst.o \
cnmdptst.o cnormtst.o cnumtst.o cregrtst.o crestst.o creststn.o cturtst.o \
cucdtst.o cutiltst.o encoll.o nucnvtst.o susctest.o nccbtst.o \
cbiditst.o cbididat.o eurocreg.o udatatst.o utf16tst.o

4
icu4c/source/test/cintltst/cintltst.c
View file

@ -56,7 +56,7 @@ int main ( int argc, const char **argv )
return 1;
}
rb = ures_open(0, "en", &errorCode);
rb = ures_open(NULL, "en", &errorCode);
if(U_SUCCESS(errorCode)) {
/* ok */
ures_close(rb);
@ -79,7 +79,7 @@ void
ctest_pathnameInContext( char* fullname, int32_t maxsize, const char* relPath )
{
char mainDirBuffer[200];
char* mainDir;
char* mainDir = NULL;
const char inpSepChar = '|';
char* tmp;
int32_t lenMainDir;

9
icu4c/source/test/cintltst/cintltst.dsp
View file

@ -75,6 +75,7 @@ BSC32=bscmake.exe
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 ..\..\..\lib\debug\icuuc.lib ..\..\..\lib\debug\icui18n.lib ..\..\..\lib\debug\ctestfw.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# SUBTRACT LINK32 /profile
!ENDIF
@ -219,6 +220,10 @@ SOURCE=.\crestst.c
# End Source File
# Begin Source File
SOURCE=.\creststn.c
# End Source File
# Begin Source File
SOURCE=.\cturtst.c
# End Source File
# Begin Source File
@ -375,6 +380,10 @@ SOURCE=.\crestst.h
# End Source File
# Begin Source File
SOURCE=.\creststn.h
# End Source File
# Begin Source File
SOURCE=.\cturtst.h
# End Source File
# Begin Source File

790
icu4c/source/test/cintltst/creststn.c Normal file
View file

@ -0,0 +1,790 @@
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-1999, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/********************************************************************************
*
* File CRESTST.C
*
* Modification History:
* Name Date Description
* Madhu Katragadda 05/09/2000 Ported Tests for New ResourceBundle API
*********************************************************************************
*/
#include "unicode/utypes.h"
#include "cintltst.h"
#include "unicode/utypes.h"
#include "unicode/ustring.h"
#include "string.h"
#include "cstring.h"
#include <time.h>
#define RESTEST_HEAP_CHECK 0
#include "unicode/uloc.h"
#include "unicode/ures.h"
#include "creststn.h"
#include "unicode/ctest.h"
#include <stdio.h>
/*****************************************************************************/
/**
* Return a random unsigned long l where 0N <= l <= ULONG_MAX.
*/
static uint32_t
randul()
{
uint32_t l;
int32_t i;
static bool_t initialized = FALSE;
if (!initialized)
{
srand((unsigned)time(NULL));
initialized = TRUE;
}
// Assume rand has at least 12 bits of precision
for (i=0; i<sizeof(l); ++i) ((char*)&l)[i] = (rand() & 0x0FF0) >> 4;
return l;
}
/**
* Return a random double x where 0.0 <= x < 1.0.
*/
static double
randd()
{
return ((double)randul()) / ULONG_MAX;
}
/**
* Return a random integer i where 0 <= i < n.
*/
static int32_t randi(int32_t n)
{
return (int32_t)(randd() * n);
}
//***************************************************************************************
/**
* Convert an integer, positive or negative, to a character string radix 10.
*/
static char*
itoa1(int32_t i, char* buf)
{
char *p = 0;
char* result = buf;
/* Handle negative */
if(i < 0) {
*buf++ = '-';
i = -i;
}
/* Output digits in reverse order */
p = buf;
do {
*p++ = '0' + (i % 10);
i /= 10;
}
while(i);
*p-- = 0;
/* Reverse the string */
while(buf < p) {
char c = *buf;
*buf++ = *p;
*p-- = c;
}
return result;
}
static const int32_t kERROR_COUNT = -1234567;
static const UChar kERROR[] = { 0x0045 /*E*/, 0x0052 /*'R'*/, 0x0052 /*'R'*/,
0x004F /*'O'*/, 0x0052/*'R'*/, 0x0000 /*'\0'*/};
/*****************************************************************************/
enum E_Where
{
e_Root,
e_te,
e_te_IN,
e_Where_count
};
typedef enum E_Where E_Where;
/*****************************************************************************/
#define CONFIRM_EQ(actual,expected) if (u_strcmp(expected,actual)==0){ record_pass(); } else { record_fail(); log_err("%s returned %s instead of %s\n", action, austrdup(actual), austrdup(expected)); pass=FALSE; }
#define CONFIRM_INT_EQ(actual,expected) if ((expected)==(actual)) { record_pass(); } else { record_fail(); log_err("%s returned %d instead of %d\n", action, actual, expected); pass=FALSE; }
#define CONFIRM_INT_GE(actual,expected) if ((actual)>=(expected)) { record_pass(); } else { record_fail(); log_err("%s returned %d instead of x >= %d\n", action, actual, expected); pass=FALSE; }
#define CONFIRM_INT_NE(actual,expected) if ((expected)!=(actual)) { record_pass(); } else { record_fail(); log_err("%s returned %d instead of x != %d\n", action, actual, expected); pass=FALSE; }
#define CONFIRM_ErrorCode(actual,expected) if ((expected)==(actual)) { record_pass(); } else { record_fail(); log_err("%s returned %s instead of %s\n", action, myErrorName(actual), myErrorName(expected)); pass=FALSE; }
/* Array of our test objects */
static struct
{
const char* name;
UErrorCode expected_constructor_status;
E_Where where;
bool_t like[e_Where_count];
bool_t inherits[e_Where_count];
}
param[] =
{
/* "te" means test */
/* "IN" means inherits */
/* "NE" or "ne" means "does not exist" */
{ "root", U_ZERO_ERROR, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } },
{ "te", U_ZERO_ERROR, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } },
{ "te_IN", U_ZERO_ERROR, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },
{ "te_NE", U_USING_FALLBACK_ERROR, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } },
{ "te_IN_NE", U_USING_FALLBACK_ERROR, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },
{ "ne", U_USING_DEFAULT_ERROR, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } }
};
static int32_t bundles_count = sizeof(param) / sizeof(param[0]);
static void printUChars(UChar*);
/***************************************************************************************/
/* Array of our test objects */
void addNEWResourceBundleTest(TestNode** root)
{
addTest(root, &TestConstruction1, "tsutil/creststn/TestConstruction1");
addTest(root, &TestConstruction2, "tsutil/creststn/TestConstruction2");
addTest(root, &TestResourceBundles, "tsutil/creststn/TestResourceBundle");
addTest(root, &TestFallback, "tsutil/creststn/TestFallback");
addTest(root, &TestAliasConflict, "tsutil/creststn/TestAlias");
}
/***************************************************************************************/
void TestAliasConflict(void) {
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *he = NULL;
UResourceBundle *iw = NULL;
const UChar *result = NULL;
he = ures_open(NULL, "he", &status);
iw = ures_open(NULL, "iw", &status);
if(U_FAILURE(status)) {
log_err("Failed to get resource with %s", myErrorName(status));
}
ures_close(iw);
result = ures_get(he, "ShortLanguage", &status);
if(U_FAILURE(status) || result == NULL) {
log_err("Failed to get resource with %s", myErrorName(status));
}
ures_close(he);
}
void TestResourceBundles()
{
testTag("only_in_Root", TRUE, FALSE, FALSE);
testTag("in_Root_te", TRUE, TRUE, FALSE);
testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE);
testTag("in_Root_te_IN", TRUE, FALSE, TRUE);
testTag("only_in_te", FALSE, TRUE, FALSE);
testTag("only_in_te_IN", FALSE, FALSE, TRUE);
testTag("in_te_te_IN", FALSE, TRUE, TRUE);
testTag("nonexistent", FALSE, FALSE, FALSE);
log_verbose("Passed:= %d Failed= %d \n", pass, fail);
}
void TestConstruction1()
{
UResourceBundle *test1 = 0, *test2 = 0;
const UChar *result1, *result2;
UErrorCode status= U_ZERO_ERROR;
UErrorCode err = U_ZERO_ERROR;
const char* directory=NULL;
const char* locale="te_IN";
char testdatapath[256];
int32_t len1=0;
int32_t len2=0;
U_STRING_DECL(rootVal, "ROOT", 4);
U_STRING_DECL(te_inVal, "TE_IN", 5);
U_STRING_INIT(rootVal, "ROOT", 4);
U_STRING_INIT(te_inVal, "TE_IN", 5);
directory= ctest_getTestDirectory();
uprv_strcpy(testdatapath, directory);
uprv_strcat(testdatapath, "testdata");
log_verbose("Testing ures_open()......\n");
test1=ures_open(testdatapath, NULL, &err);
test2=ures_open(testdatapath, locale, &err);
if(U_FAILURE(err))
{
log_err("construction did not succeed : %s \n", myErrorName(status));
return;
}
result1= ures_getStringByKey(test1, "string_in_Root_te_te_IN", &len1, &err);
result2= ures_getStringByKey(test2, "string_in_Root_te_te_IN", &len2, &err);
if (U_FAILURE(err) || len1==0 || len2==0) {
log_err("Something threw an error in TestConstruction(): %s\n", myErrorName(status));
return;
}
log_verbose("for string_in_Root_te_te_IN, default.txt had %s\n", austrdup(result1));
log_verbose("for string_in_Root_te_te_IN, te_IN.txt had %s\n", austrdup(result2));
if(u_strcmp(result1, rootVal) !=0 || u_strcmp(result2, te_inVal) !=0 ){
log_err("construction test failed. Run Verbose for more information");
}
/* Test getVersionNumber*/
log_verbose("Testing version number\n");
log_verbose("for getVersionNumber : %s\n", ures_getVersionNumber(test1));
ures_close(test1);
ures_close(test2);
}
void TestConstruction2()
{
UChar temp[7];
UResourceBundle *test4 = 0;
const UChar* result4;
UErrorCode err = U_ZERO_ERROR;
const char* directory;
const char* locale="te_IN";
wchar_t widedirectory[256];
char testdatapath[256];
int32_t len=0;
directory= ctest_getTestDirectory();
uprv_strcpy(testdatapath, directory);
uprv_strcat(testdatapath, "testdata");
mbstowcs(widedirectory, testdatapath, 256);
log_verbose("Testing ures_openW().......\n");
test4=ures_openW(widedirectory, locale, &err);
if(U_FAILURE(err)){
log_err("Error in the construction using ures_openW(): %s\n", myErrorName(err));
return;
}
result4=ures_getStringByKey(test4, "string_in_Root_te_te_IN", &len, &err);
if (U_FAILURE(err) || len==0) {
log_err("Something threw an error in TestConstruction() %s\n", myErrorName(err));
return;
}
log_verbose("for string_in_Root_te_te_IN, te_IN.txt had %s\n", austrdup(result4));
u_uastrcpy(temp, "TE_IN");
if(u_strcmp(result4, temp)!=0)
{
log_err("Construction test failed for ures_openW();\n");
if(!VERBOSITY)
log_info("(run verbose for more information)\n");
log_verbose("\nGot->");
printUChars((UChar*)result4);
log_verbose(" Want->");
printUChars(temp);
log_verbose("\n");
}
ures_close(test4);
}
/*****************************************************************************/
/*****************************************************************************/
bool_t testTag(const char* frag,
bool_t in_Root,
bool_t in_te,
bool_t in_te_IN)
{
bool_t pass=TRUE;
/* Make array from input params */
bool_t is_in[3];
const char *NAME[] = { "ROOT", "TE", "TE_IN" };
/* Now try to load the desired items */
UResourceBundle* theBundle = NULL;
char tag[99];
char action[256];
UErrorCode expected_status,status = U_ZERO_ERROR,expected_resource_status = U_ZERO_ERROR;
UChar* base = NULL;
UChar* expected_string = NULL;
const UChar* string = NULL;
char buf[5];
char item_tag[10];
int32_t i,j,row,col, len;
int32_t actual_bundle;
int32_t count = 0;
int32_t row_count=0;
int32_t column_count=0;
int32_t index = 0;
int32_t tag_count= 0;
char testdatapath[256];
UResourceBundle* array=NULL;
UResourceBundle* array2d=NULL;
UResourceBundle* tags=NULL;
UResourceBundle* arrayItem1=NULL;
const char* directory = ctest_getTestDirectory();
uprv_strcpy(testdatapath, directory);
uprv_strcat(testdatapath, "testdata");
is_in[0] = in_Root;
is_in[1] = in_te;
is_in[2] = in_te_IN;
strcpy(item_tag, "tag");
for (i=0; i<bundles_count; ++i)
{
strcpy(action,"construction for");
strcat(action, param[i].name);
status = U_ZERO_ERROR;
theBundle = ures_open(testdatapath, param[i].name, &status);
CONFIRM_ErrorCode(status,param[i].expected_constructor_status);
if(i == 5)
actual_bundle = 0; /* ne -> default */
else if(i == 3)
actual_bundle = 1; /* te_NE -> te */
else if(i == 4)
actual_bundle = 2; /* te_IN_NE -> te_IN */
else
actual_bundle = i;
expected_resource_status = U_MISSING_RESOURCE_ERROR;
for (j=e_te_IN; j>=e_Root; --j)
{
if (is_in[j] && param[i].inherits[j])
{
if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */
expected_resource_status = U_ZERO_ERROR;
else if(j == 0)
expected_resource_status = U_USING_DEFAULT_ERROR;
else
expected_resource_status = U_USING_FALLBACK_ERROR;
log_verbose("%s[%d]::%s: in<%d:%s> inherits<%d:%s>. actual_bundle=%s\n",
param[i].name,
i,
frag,
j,
is_in[j]?"Yes":"No",
j,
param[i].inherits[j]?"Yes":"No",
param[actual_bundle].name);
break;
}
}
for (j=param[i].where; j>=0; --j)
{
if (is_in[j])
{
base=(UChar*)malloc(sizeof(UChar)*(strlen(NAME[j]) + 1));
u_uastrcpy(base,NAME[j]);
break;
}
else {
base = (UChar*) malloc(sizeof(UChar) * 1);
*base = 0x0000;
}
}
/*----string---------------------------------------------------------------- */
strcpy(tag,"string_");
strcat(tag,frag);
strcpy(action,param[i].name);
strcat(action, ".ures_getStringByKey(" );
strcat(action,tag);
strcat(action, ")");
status = U_ZERO_ERROR;
len=0;
string=ures_getStringByKey(theBundle, tag, &len, &status);
if(U_SUCCESS(status)) {
expected_string=(UChar*)malloc(sizeof(UChar)*(u_strlen(base) + 4));
u_strcpy(expected_string,base);
CONFIRM_INT_EQ(len, u_strlen(expected_string));
}else{
expected_string = (UChar*)malloc(sizeof(UChar)*(u_strlen(kERROR) + 1));
u_strcpy(expected_string,kERROR);
string=kERROR;
}
log_verbose("%s got %d, expected %d\n", action, status, expected_resource_status);
CONFIRM_ErrorCode(status, expected_resource_status);
CONFIRM_EQ(string, expected_string);
/*--------------array------------------------------------------------- */
strcpy(tag,"array_");
strcat(tag,frag);
strcpy(action,param[i].name);
strcat(action, ".ures_getByKey(" );
strcat(action,tag);
strcat(action, ")");
len=0;
count = kERROR_COUNT;
status = U_ZERO_ERROR;
array=ures_getByKey(theBundle, tag, array, &status);
CONFIRM_ErrorCode(status,expected_resource_status);
if (U_SUCCESS(status)) {
//confirm the resource type is an array
CONFIRM_INT_EQ(ures_getType(array), RES_ARRAY);
//confirm the size
count=ures_getSize(array);
CONFIRM_INT_GE(count,1);
for (j=0; j<count; ++j) {
UChar element[3];
u_strcpy(expected_string, base);
u_uastrcpy(element, itoa1(j,buf));
u_strcat(expected_string, element);
arrayItem1=ures_getNextResource(array, arrayItem1, &status);
if(U_SUCCESS(status)){
CONFIRM_EQ(ures_getString(arrayItem1, &len, &status),expected_string);
}
}
}
else {
CONFIRM_INT_EQ(count,kERROR_COUNT);
CONFIRM_INT_EQ((int32_t)(unsigned long)array,(int32_t)0);
count = 0;
}
/*--------------arrayItem------------------------------------------------- */
strcpy(tag,"array_");
strcat(tag,frag);
strcpy(action,param[i].name);
strcat(action, ".ures_getStringByIndex(");
strcat(action, tag);
strcat(action, ")");
for (j=0; j<10; ++j){
index = count ? (randi(count * 3) - count) : (randi(200) - 100);
status = U_ZERO_ERROR;
string=kERROR;
array=ures_getByKey(theBundle, tag, array, &status);
if(!U_FAILURE(status)){
UChar *t=NULL;
t=(UChar*)ures_getStringByIndex(array, index, &len, &status);
if(!U_FAILURE(status)){
UChar element[3];
string=t;
u_strcpy(expected_string, base);
u_uastrcpy(element, itoa1(index,buf));
u_strcat(expected_string, element);
} else {
u_strcpy(expected_string, kERROR);
}
}
expected_status = (index >= 0 && index < count) ? expected_resource_status : U_MISSING_RESOURCE_ERROR;
CONFIRM_ErrorCode(status,expected_status);
CONFIRM_EQ(string,expected_string);
}
/*--------------2dArray------------------------------------------------- */
strcpy(tag,"array_2d_");
strcat(tag,frag);
strcpy(action,param[i].name);
strcat(action, ".ures_getByKey(" );
strcat(action,tag);
strcat(action, ")");
row_count = kERROR_COUNT, column_count = kERROR_COUNT;
status = U_ZERO_ERROR;
array2d=ures_getByKey(theBundle, tag, array2d, &status);
CONFIRM_ErrorCode(status,expected_resource_status);
if (U_SUCCESS(status))
{
//confirm the resource type is an 2darray
CONFIRM_INT_EQ(ures_getType(array2d), RES_ARRAY);
row_count=ures_getSize(array2d);
CONFIRM_INT_GE(row_count,1);
for(row=0; row<row_count; ++row){
UResourceBundle *tableRow=NULL;
tableRow=ures_getByIndex(array2d, row, tableRow, &status);
CONFIRM_ErrorCode(status, expected_resource_status);
if(U_SUCCESS(status)){
//confirm the resourcetype of each table row is an array
CONFIRM_INT_EQ(ures_getType(tableRow), RES_ARRAY);
column_count=ures_getSize(tableRow);
CONFIRM_INT_GE(column_count,1);
for (col=0; j<column_count; ++j) {
UChar element[3];
u_strcpy(expected_string, base);
u_uastrcpy(element, itoa1(row, buf));
u_strcat(expected_string, element);
u_uastrcpy(element, itoa1(col, buf));
u_strcat(expected_string, element);
arrayItem1=ures_getNextResource(tableRow, arrayItem1, &status);
if(U_SUCCESS(status)){
const UChar *stringValue=ures_getString(arrayItem1, &len, &status);
CONFIRM_EQ(stringValue, expected_string);
}
}
}
}
}else{
CONFIRM_INT_EQ(row_count,kERROR_COUNT);
CONFIRM_INT_EQ(column_count,kERROR_COUNT);
row_count=column_count=0;
}
/*------2dArrayItem-------------------------------------------------------------- */
// 2dArrayItem
for (j=0; j<10; ++j)
{
row = row_count ? (randi(row_count * 3) - row_count) : (randi(200) - 100);
col = column_count ? (randi(column_count * 3) - column_count) : (randi(200) - 100);
status = U_ZERO_ERROR;
string = kERROR;
len=0;
array2d=ures_getByKey(theBundle, tag, array2d, &status);
if(U_SUCCESS(status)){
UResourceBundle *tableRow=NULL;
tableRow=ures_getByIndex(array2d, row, tableRow, &status);
if(U_SUCCESS(status)) {
UChar *t=NULL;
t=(UChar*)ures_getStringByIndex(tableRow, col, &len, &status);
if(U_SUCCESS(status)){
string=t;
}
}
}
expected_status = (row >= 0 && row < row_count && col >= 0 && col < column_count) ?
expected_resource_status: U_MISSING_RESOURCE_ERROR;
CONFIRM_ErrorCode(status,expected_status);
if (U_SUCCESS(status)){
UChar element[3];
u_strcpy(expected_string, base);
u_uastrcpy(element, itoa1(row, buf));
u_strcat(expected_string, element);
u_uastrcpy(element, itoa1(col, buf));
u_strcat(expected_string, element);
} else {
u_strcpy(expected_string,kERROR);
}
CONFIRM_EQ(string,expected_string);
}
/*--------------taggedArray----------------------------------------------- */
strcpy(tag,"tagged_array_");
strcat(tag,frag);
strcpy(action,param[i].name);
strcat(action,".ures_getByKey(");
strcat(action, tag);
strcat(action,")");
status = U_ZERO_ERROR;
tag_count=0;
tags=ures_getByKey(theBundle, tag, tags, &status);
CONFIRM_ErrorCode(status, expected_resource_status);
if (U_SUCCESS(status)) {
UResType bundleType=ures_getType(tags);
CONFIRM_INT_EQ(bundleType, RES_TABLE);
tag_count=ures_getSize(tags);
CONFIRM_INT_GE((int32_t)tag_count, (int32_t)0);
for(index=0; index <tag_count; index++){
UResourceBundle *tagelement=NULL;
char *key=NULL;
UChar* value=NULL;
tagelement=ures_getByIndex(tags, index, tagelement, &status);
key=(char*)ures_getKey(tagelement);
value=(UChar*)ures_getNextString(tagelement, &len, &key, &status);
log_verbose("tag = %s, value = %s\n", key, austrdup(value));
if(strncmp(key, "tag", 3) == 0 && u_strncmp(value, base, u_strlen(base)) == 0){
record_pass();
}else{
record_fail();
}
}
}else{
tag_count=0;
}
//---------taggedArrayItem----------------------------------------------
count = 0;
for (index=-20; index<20; ++index)
{
status = U_ZERO_ERROR;
string = kERROR;
strcpy(item_tag, "tag");
strcat(item_tag, itoa1(index,buf));
tags=ures_getByKey(theBundle, tag, tags, &status);
if(U_SUCCESS(status)){
UResourceBundle *tagelement=NULL;
UChar *t=NULL;
tagelement=ures_getByKey(tags, item_tag, tagelement, &status);
if(!U_FAILURE(status)){
UResType elementType=ures_getType(tagelement);
CONFIRM_INT_EQ(elementType, RES_STRING);
if(strcmp(ures_getKey(tagelement), item_tag) == 0){
record_pass();
}else{
record_fail();
}
t=(UChar*)ures_getString(tagelement, &len, &status);
if(!U_FAILURE(status)){
string=t;
}
}
if (index < 0) {
CONFIRM_ErrorCode(status,U_MISSING_RESOURCE_ERROR);
}
else{
if (status != U_MISSING_RESOURCE_ERROR) {
UChar element[3];
u_strcpy(expected_string, base);
u_uastrcpy(element, itoa1(index,buf));
u_strcat(expected_string, element);
CONFIRM_EQ(string,expected_string);
count++;
}
}
}
}
CONFIRM_INT_EQ(count, tag_count);
free(expected_string);
free(base);
ures_close(theBundle);
}
return pass;
}
void record_pass()
{
++pass;
}
void record_fail()
{
++fail;
}
/**
* Test to make sure that the U_USING_FALLBACK_ERROR and U_USING_DEFAULT_ERROR
* are set correctly
*/
void TestFallback()
{
UErrorCode status = U_ZERO_ERROR;
UResourceBundle *fr_FR = NULL;
const UChar *junk; /* ignored */
log_verbose("Opening fr_FR..");
fr_FR = ures_open(NULL, "fr_FR", &status);
if(U_FAILURE(status))
{
log_err("Couldn't open fr_FR - %d\n", status);
return;
}
status = U_ZERO_ERROR;
/* clear it out.. just do some calls to get the gears turning */
junk = ures_get(fr_FR, "LocaleID", &status);
status = U_ZERO_ERROR;
junk = ures_get(fr_FR, "LocaleString", &status);
status = U_ZERO_ERROR;
junk = ures_get(fr_FR, "LocaleID", &status);
status = U_ZERO_ERROR;
/* OK first one. This should be a Default value. */
junk = ures_get(fr_FR, "Version", &status);
if(status != U_USING_DEFAULT_ERROR)
{
log_err("Expected U_USING_DEFAULT_ERROR when trying to get Version from fr_FR, got %d\n",
status);
}
status = U_ZERO_ERROR;
/* and this is a Fallback, to fr */
junk = ures_get(fr_FR, "ShortLanguage", &status);
if(status != U_USING_FALLBACK_ERROR)
{
log_err("Expected U_USING_FALLBACK_ERROR when trying to get ShortLanguage from fr_FR, got %d\n",
status);
}
status = U_ZERO_ERROR;
ures_close(fr_FR);
}
void printUChars(UChar* uchars){
int16_t i=0;
for(i=0; i<u_strlen(uchars); i++){
printf("%04X ", *(uchars+i));
}
}

53
icu4c/source/test/cintltst/creststn.h Normal file
View file

@ -0,0 +1,53 @@
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-1999, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
/********************************************************************************
*
* File CRESTST.H
*
* Modification History:
* Name Date Description
* Madhu Katragadda 05/09/200 Ported Tests for New ResourceBundle API
*********************************************************************************
*/
#ifndef _CRESTSTN
#define _CRESTSTN
/* C TEST FOR NEW RESOURCEBUNDLE API*/
#include "cintltst.h"
void addNEWResourceBundleTest(TestNode**);
/**
*Perform several extensive tests using the subtest routine testTag
*/
static void TestResourceBundles(void);
/**
* Test construction of ResourceBundle accessing a custom test resource-file
**/
static void TestConstruction1(void);
static void TestConstruction2(void);
static void TestAliasConflict(void);
static void TestFallback(void);
/**
* extensive subtests called by TestResourceBundles
**/
static bool_t testTag(const char* frag, bool_t in_Root, bool_t in_te, bool_t in_te_IN);
static void record_pass(void);
static void record_fail(void);
static int32_t pass;
static int32_t fail;
#endif

2
icu4c/source/test/cintltst/cutiltst.c
View file

@ -17,6 +17,7 @@
void addLocaleTest(TestNode**);
void addUnicodeTest(TestNode**);
void addResourceBundleTest(TestNode**);
void addNEWResourceBundleTest(TestNode**);
void addSCSUTest(TestNode** root);
void addHashtableTest(TestNode** root);
@ -25,6 +26,7 @@ void addUtility(TestNode** root)
addLocaleTest(root);
addUnicodeTest(root);
addResourceBundleTest(root);
addNEWResourceBundleTest(root);
addSCSUTest(root);
addHashtableTest(root);
}

2
icu4c/source/test/intltest/Makefile.in
View file

@ -61,7 +61,7 @@ dcfmapts.o decoll.o dtfmapts.o dtfmrgts.o dtfmtrtts.o dtfmttst.o \
encoll.o escoll.o ficoll.o frcoll.o g7coll.o intltest.o isocoll.o \
itconv.o itercoll.o itformat.o itmajor.o ittxtbd.o itutil.o jacoll.o \
loctest.o miscdtfm.o mnkytst.o msfmrgts.o nmfmapts.o nmfmtrt.o \
numfmtst.o numrgts.o pptest.o regcoll.o restest.o sdtfmtts.o tchcfmt.o \
numfmtst.o numrgts.o pptest.o regcoll.o restest.o restsnew.o sdtfmtts.o tchcfmt.o \
tfsmalls.o tmsgfmt.o trcoll.o tscoll.o tsdate.o tsdcfmsy.o tsdtfmsy.o \
tsmthred.o tsmutex.o tsnmfmt.o tsputil.o tstnorm.o tzbdtest.o \
tzregts.o tztest.o ucdtest.o usettest.o ustrtest.o transtst.o strtest.o thcoll.o \

23
icu4c/source/test/intltest/intltest.dsp
View file

@ -66,7 +66,7 @@ LINK32=link.exe
# PROP Ignore_Export_Lib 0
# PROP Target_Dir ""
# ADD BASE CPP /nologo /W3 /Gm /GX /ZI /Od /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\include" /I "..\..\..\source\common" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /YX /FD /GZ /c
# ADD CPP /nologo /MDd /W3 /Gm /GX /ZI /Od /I "..\..\..\include" /I "..\..\..\source\common" /D "WIN32" /D "_DEBUG" /D "_CONSOLE" /D "_MBCS" /D "UDATA_MAP_DLL" /YX /FD /GZ /c
# ADD BASE RSC /l 0x409 /d "_DEBUG"
# ADD RSC /l 0x409 /d "_DEBUG"
BSC32=bscmake.exe
@ -116,6 +116,15 @@ SOURCE=.\citrtest.cpp
# Begin Source File
SOURCE=.\cpdtrtst.cpp
!IF "$(CFG)" == "intltest - Win32 Release"
!ELSEIF "$(CFG)" == "intltest - Win32 Debug"
# ADD CPP /YX
!ENDIF
# End Source File
# Begin Source File
@ -287,6 +296,10 @@ SOURCE=.\restest.cpp
# End Source File
# Begin Source File
SOURCE=.\restsnew.cpp
# End Source File
# Begin Source File
SOURCE=.\sdtfmtts.cpp
# End Source File
# Begin Source File
@ -591,6 +604,10 @@ SOURCE=.\restest.h
# End Source File
# Begin Source File
SOURCE=.\restsnew.h
# End Source File
# Begin Source File
SOURCE=.\sdtfmtts.h
# End Source File
# Begin Source File
@ -683,6 +700,10 @@ SOURCE=..\..\i18n\uniset.h
# End Source File
# Begin Source File
SOURCE=..\..\common\unicode\ures.h
# End Source File
# Begin Source File
SOURCE=.\usettest.h
# End Source File
# Begin Source File

15
icu4c/source/test/intltest/itutil.cpp
View file

@ -17,6 +17,7 @@
#include "ustrtest.h"
#include "ucdtest.h"
#include "restest.h"
#include "restsnew.h"
#include "tsmutex.h"
#include "tsmthred.h"
#include "tsputil.h"
@ -83,8 +84,16 @@ void IntlTestUtilities::runIndexedTest( int32_t index, bool_t exec, char* &name,
callTest( test, par );
}
break;
case 6:
name = "NewResourceBundleTest";
if (exec) {
logln("NewResourceBundleTest---"); logln("");
NewResourceBundleTest test;
callTest( test, par );
}
break;
case 6:
case 7:
name = "MutexTest";
if (exec) {
logln("MutexTest---"); logln("");
@ -93,7 +102,7 @@ void IntlTestUtilities::runIndexedTest( int32_t index, bool_t exec, char* &name,
}
break;
case 7:
case 8:
name = "MultithreadTest";
if (exec) {
logln("MultithreadTest---"); logln("");
@ -102,7 +111,7 @@ void IntlTestUtilities::runIndexedTest( int32_t index, bool_t exec, char* &name,
}
break;
case 8:
case 9:
name = "PUtilTest";
if (exec) {
logln("PUtilTest---"); logln("");

812
icu4c/source/test/intltest/restsnew.cpp Normal file
View file

@ -0,0 +1,812 @@
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-1999, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#include <time.h>
#include <string.h>
#include <limits.h>
#define RESTEST_HEAP_CHECK 0
#include "unicode/utypes.h"
#if defined(_WIN32) && !defined(__WINDOWS__)
#define _CRTDBG_MAP_ALLOC
#include <crtdbg.h>
#endif
#include "cstring.h"
#include "unicode/unistr.h"
#include "unicode/resbund.h"
#include "restsnew.h"
//***************************************************************************************
static const UnicodeString kERROR = UNICODE_STRING("ERROR", 5);
static const UChar kErrorUChars[] = { 0x45, 0x52, 0x52, 0x4f, 0x52, 0 };
static const kErrorLength = 5;
static const int32_t kERROR_COUNT = -1234567;
//***************************************************************************************
enum E_Where
{
e_Root,
e_te,
e_te_IN,
e_Where_count
};
//***************************************************************************************
#define CONFIRM_EQ(actual,expected) if ((expected)==(actual)) { record_pass(); } else { record_fail(); OUT << action << " returned " << (actual) << " instead of " << (expected) << endl; pass=FALSE; }
#define CONFIRM_GE(actual,expected) if ((actual)>=(expected)) { record_pass(); } else { record_fail(); OUT << action << " returned " << (actual) << " instead of x >= " << (expected) << endl; pass=FALSE; }
#define CONFIRM_NE(actual,expected) if ((expected)!=(actual)) { record_pass(); } else { record_fail(); OUT << action << " returned " << (actual) << " instead of x != " << (expected) << endl; pass=FALSE; }
#define CONFIRM_UErrorCode(actual,expected) if ((expected)==(actual)) { record_pass(); } else { record_fail(); OUT << action << " returned " << u_errorName(actual) << " instead of " << u_errorName(expected) << endl; pass=FALSE; }
//***************************************************************************************
/**
* Convert an integer, positive or negative, to a character string radix 10.
*/
static char*
itoa(int32_t i, char* buf)
{
char* result = buf;
// Handle negative
if (i < 0)
{
*buf++ = '-';
i = -i;
}
// Output digits in reverse order
char* p = buf;
do
{
*p++ = '0' + (i % 10);
i /= 10;
}
while (i);
*p-- = 0;
// Reverse the string
while (buf < p)
{
char c = *buf;
*buf++ = *p;
*p-- = c;
}
return result;
}
//***************************************************************************************
// Array of our test objects
static struct
{
const char* name;
Locale *locale;
UErrorCode expected_constructor_status;
E_Where where;
bool_t like[e_Where_count];
bool_t inherits[e_Where_count];
}
param[] =
{
// "te" means test
// "IN" means inherits
// "NE" or "ne" means "does not exist"
{ "root", 0, U_ZERO_ERROR, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } },
{ "te", 0, U_ZERO_ERROR, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } },
{ "te_IN", 0, U_ZERO_ERROR, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },
{ "te_NE", 0, U_USING_FALLBACK_ERROR, e_te, { FALSE, TRUE, FALSE }, { TRUE, TRUE, FALSE } },
{ "te_IN_NE", 0, U_USING_FALLBACK_ERROR, e_te_IN, { FALSE, FALSE, TRUE }, { TRUE, TRUE, TRUE } },
{ "ne", 0, U_USING_DEFAULT_ERROR, e_Root, { TRUE, FALSE, FALSE }, { TRUE, FALSE, FALSE } }
};
static int32_t bundles_count = sizeof(param) / sizeof(param[0]);
//***************************************************************************************
/**
* Return a random unsigned long l where 0N <= l <= ULONG_MAX.
*/
static uint32_t
randul()
{
static bool_t initialized = FALSE;
if (!initialized)
{
srand((unsigned)time(NULL));
initialized = TRUE;
}
// Assume rand has at least 12 bits of precision
uint32_t l;
for (int32_t i=0; i<sizeof(l); ++i) ((char*)&l)[i] = (rand() & 0x0FF0) >> 4;
return l;
}
/**
* Return a random double x where 0.0 <= x < 1.0.
*/
static double
randd()
{
return ((double)randul()) / ULONG_MAX;
}
/**
* Return a random integer i where 0 <= i < n.
*/
static int32_t randi(int32_t n)
{
return (int32_t)(randd() * n);
}
//***************************************************************************************
NewResourceBundleTest::NewResourceBundleTest()
: pass(0),
fail(0),
OUT(it_out)
{
param[0].locale = new Locale("root");
param[1].locale = new Locale("te");
param[2].locale = new Locale("te", "IN");
param[3].locale = new Locale("te", "NE");
param[4].locale = new Locale("te", "IN", "NE");
param[5].locale = new Locale("ne");
}
NewResourceBundleTest::~NewResourceBundleTest()
{
}
void NewResourceBundleTest::runIndexedTest( int32_t index, bool_t exec, char* &name, char* par )
{
if (exec) logln("TestSuite ResourceBundleTest: ");
switch (index) {
case 0: name = "TestResourceBundles"; if (exec) TestResourceBundles(); break;
case 1: name = "TestConstruction"; if (exec) TestConstruction(); break;
case 2: name = "TestIteration"; if (exec) TestIteration(); break;
default: name = ""; break; //needed to end loop
}
}
//***************************************************************************************
void
NewResourceBundleTest::TestResourceBundles()
{
#if defined(_WIN32) && !defined(__WINDOWS__)
#if defined(_DEBUG) && RESTEST_HEAP_CHECK
/*
* Set the debug-heap flag to keep freed blocks in the
* heap's linked list - This will allow us to catch any
* inadvertent use of freed memory
*/
int tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;
tmpDbgFlag |= _CRTDBG_LEAK_CHECK_DF;
tmpDbgFlag |= _CRTDBG_CHECK_ALWAYS_DF;
_CrtSetDbgFlag(tmpDbgFlag);
_CrtMemState memstate;
_CrtMemCheckpoint(&memstate);
{
#endif
#endif
testTag("only_in_Root", TRUE, FALSE, FALSE);
testTag("only_in_te", FALSE, TRUE, FALSE);
testTag("only_in_te_IN", FALSE, FALSE, TRUE);
testTag("in_Root_te", TRUE, TRUE, FALSE);
testTag("in_Root_te_te_IN", TRUE, TRUE, TRUE);
testTag("in_Root_te_IN", TRUE, FALSE, TRUE);
testTag("in_te_te_IN", FALSE, TRUE, TRUE);
testTag("nonexistent", FALSE, FALSE, FALSE);
OUT << "Passed: " << pass << "\nFailed: " << fail << endl;
#if defined(_WIN32) && !defined(__WINDOWS__)
#if defined(_DEBUG) && RESTEST_HEAP_CHECK
}
_CrtMemDumpAllObjectsSince(&memstate);
/*
* Set the debug-heap flag to keep freed blocks in the
* heap's linked list - This will allow us to catch any
* inadvertent use of freed memory
*/
tmpDbgFlag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
tmpDbgFlag |= _CRTDBG_DELAY_FREE_MEM_DF;
tmpDbgFlag &= ~_CRTDBG_LEAK_CHECK_DF;
tmpDbgFlag &= ~_CRTDBG_CHECK_ALWAYS_DF;
_CrtSetDbgFlag(tmpDbgFlag);
#endif
#endif
}
void
NewResourceBundleTest::TestConstruction()
{
{
UErrorCode err = U_ZERO_ERROR;
const char *directory;
char testdatapath[256];
Locale locale("te", "IN");
directory=IntlTest::getTestDirectory();
uprv_strcpy(testdatapath, directory);
uprv_strcat(testdatapath, "testdata");
ResourceBundle test1(testdatapath, err);
ResourceBundle test2(testdatapath, locale, err);
UnicodeString result1;
UnicodeString result2;
result1 = test1.getStringEx("string_in_Root_te_te_IN", err);
result2 = test2.getStringEx("string_in_Root_te_te_IN", err);
if (U_FAILURE(err)) {
errln("Something threw an error in TestConstruction()");
return;
}
logln("for string_in_Root_te_te_IN, root.txt had " + result1);
logln("for string_in_Root_te_te_IN, te_IN.txt had " + result2);
if (result1 != "ROOT" || result2 != "TE_IN")
errln("Construction test failed; run verbose for more information");
const char* version1;
const char* version2;
version1 = test1.getVersionNumber();
version2 = test2.getVersionNumber();
char *versionID1 = new char[1 + strlen(U_ICU_VERSION) + strlen(version1)]; // + 1 for zero byte
char *versionID2 = new char[1 + strlen(U_ICU_VERSION) + strlen(version2)]; // + 1 for zero byte
strcpy(versionID1, U_ICU_VERSION);
strcat(versionID1, ".44"); // hardcoded, please change if the default.txt file or ResourceBundle::kVersionSeparater is changed.
strcpy(versionID2, U_ICU_VERSION);
strcat(versionID2, ".55"); // hardcoded, please change if the te_IN.txt file or ResourceBundle::kVersionSeparater is changed.
logln(UnicodeString("getVersionNumber on default.txt returned ") + version1);
logln(UnicodeString("getVersionNumber on te_IN.txt returned ") + version2);
if (strcmp(version1, versionID1) != 0 || strcmp(version2, versionID2) != 0)
errln("getVersionNumber() failed");
}
{
UErrorCode err = U_ZERO_ERROR;
const char *directory;
char testdatapath[256];
Locale locale("te", "IN");
directory=IntlTest::getTestDirectory();
uprv_strcpy(testdatapath, directory);
uprv_strcat(testdatapath, "testdata");
wchar_t* wideDirectory = new wchar_t[256];
mbstowcs(wideDirectory, testdatapath, 256);
ResourceBundle test2(wideDirectory, locale, err);
UnicodeString result2;
result2 = test2.getStringEx("string_in_Root_te_te_IN", err);
if (U_FAILURE(err)) {
errln("Something threw an error in TestConstruction()");
return;
}
logln("for string_in_Root_te_te_IN, te_IN.txt had " + result2);
if (result2 != "TE_IN")
errln("Construction test failed; run verbose for more information");
}
}
void
NewResourceBundleTest::TestIteration()
{
UErrorCode err = U_ZERO_ERROR;
const char *directory;
char testdatapath[256];
const char* data[]={
"string_in_Root_te_te_IN", "1",
"array_in_Root_te_te_IN", "5",
"array_2d_in_Root_te_te_IN", "4",
};
Locale *locale=new Locale("te_IN");
directory=IntlTest::getTestDirectory();
uprv_strcpy(testdatapath, directory);
uprv_strcat(testdatapath, "testdata");
ResourceBundle test1(testdatapath, *locale, err);
if(U_FAILURE(err)){
errln("Construction failed");
}
int32_t i, count, row=0, col=0;
char buf[5];
UnicodeString expected;
UnicodeString element("TE_IN");
UnicodeString action;
for(i=0; i<sizeof(data)/sizeof(data[0]); i=i+2){
action = "te_IN";
action +=".get(";
action += data[i];
action +=", err)";
err=U_ZERO_ERROR;
ResourceBundle bundle = test1.get(data[i], err);
if(!U_FAILURE(err)){
action = "te_IN";
action +=".getKey()";
CONFIRM_EQ((UnicodeString)bundle.getKey(), (UnicodeString)data[i]);
count=0;
row=0;
while(bundle.hasNext()){
action = data[i];
action +=".getNextString(err)";
row=count;
UnicodeString got=bundle.getNextString(err);
if(U_SUCCESS(err)){
expected=element;
if(bundle.getSize() > 1){
CONFIRM_EQ(bundle.getType(), RES_ARRAY);
expected+=itoa(row, buf);
ResourceBundle rowbundle=bundle.get(row, err);
if(!U_FAILURE(err) && rowbundle.getSize()>1){
col=0;
while(rowbundle.hasNext()){
expected=element;
got=rowbundle.getNextString(err);
if(!U_FAILURE(err)){
expected+=itoa(row, buf);
expected+=itoa(col, buf);
col++;
CONFIRM_EQ(got, expected);
}
}
CONFIRM_EQ(col, rowbundle.getSize());
}
}
else{
CONFIRM_EQ(bundle.getType(), RES_STRING);
}
}
CONFIRM_EQ(got, expected);
count++;
}
action = data[i];
action +=".getSize()";
CONFIRM_EQ(bundle.getSize(), count);
CONFIRM_EQ(count, atoi(data[i+1]));
//after reaching the end
err=U_ZERO_ERROR;
ResourceBundle errbundle=bundle.getNext(err);
action = "After reaching the end of the Iterator:- ";
action +=data[i];
action +=".getNext()";
CONFIRM_NE(err, U_ZERO_ERROR);
CONFIRM_EQ(u_errorName(err), u_errorName(U_INDEX_OUTOFBOUNDS_ERROR));
//reset the iterator
err = U_ZERO_ERROR;
bundle.resetIterator();
/* The following code is causing a crash
****CRASH******
*/
bundle.getNext(err);
if(U_FAILURE(err)){
errln("ERROR: getNext() throw an error");
}/**/
}
}
}
//***************************************************************************************
bool_t
NewResourceBundleTest::testTag(const char* frag,
bool_t in_Root,
bool_t in_te,
bool_t in_te_IN)
{
bool_t pass=TRUE;
// Make array from input params
bool_t is_in[] = { in_Root, in_te, in_te_IN };
const char* NAME[] = { "ROOT", "TE", "TE_IN" };
// Now try to load the desired items
char tag[100];
UnicodeString action;
int32_t i,j,row,col, actual_bundle;
int32_t index;
const char *directory;
char testdatapath[256];
directory=IntlTest::getTestDirectory();
uprv_strcpy(testdatapath, directory);
uprv_strcat(testdatapath, "testdata");
for (i=0; i<bundles_count; ++i)
{
action = "Constructor for ";
action += param[i].name;
UErrorCode status = U_ZERO_ERROR;
ResourceBundle theBundle( testdatapath, *param[i].locale, status);
//ResourceBundle theBundle( "c:\\icu\\icu\\source\\test\\testdata\\testdata", *param[i].locale, status);
CONFIRM_UErrorCode(status,param[i].expected_constructor_status);
if(i == 5)
actual_bundle = 0; /* ne -> default */
else if(i == 3)
actual_bundle = 1; /* te_NE -> te */
else if(i == 4)
actual_bundle = 2; /* te_IN_NE -> te_IN */
else
actual_bundle = i;
UErrorCode expected_resource_status = U_MISSING_RESOURCE_ERROR;
for (j=e_te_IN; j>=e_Root; --j)
{
if (is_in[j] && param[i].inherits[j])
{
if(j == actual_bundle) /* it's in the same bundle OR it's a nonexistent=default bundle (5) */
expected_resource_status = U_ZERO_ERROR;
else if(j == 0)
expected_resource_status = U_USING_DEFAULT_ERROR;
else
expected_resource_status = U_USING_FALLBACK_ERROR;
break;
}
}
UErrorCode expected_status;
UnicodeString base;
for (j=param[i].where; j>=0; --j)
{
if (is_in[j])
{
base = NAME[j];
break;
}
}
//--------------------------------------------------------------------------
// string
uprv_strcpy(tag, "string_");
uprv_strcat(tag, frag);
action = param[i].name;
action += ".getStringEx(";
action += tag;
action += ")";
status = U_ZERO_ERROR;
UnicodeString string = theBundle.getStringEx(tag, status);
if(U_FAILURE(status)) {
string.setTo(TRUE, kErrorUChars, kErrorLength);
}
CONFIRM_UErrorCode(status, expected_resource_status);
UnicodeString expected_string;
expected_string = U_SUCCESS(status) ? base : kERROR;
CONFIRM_EQ(string, expected_string);
//--------------------------------------------------------------------------
// array ResourceBundle using the key
uprv_strcpy(tag, "array_");
uprv_strcat(tag, frag);
action = param[i].name;
action += ".get(";
action += tag;
action += ")";
int32_t count = kERROR_COUNT;
status = U_ZERO_ERROR;
ResourceBundle array = theBundle.get(tag, status);
CONFIRM_UErrorCode(status,expected_resource_status);
if (U_SUCCESS(status))
{
//confirm the resource type is an array
UResType bundleType=array.getType();
CONFIRM_EQ(bundleType, RES_ARRAY);
count=array.getSize();
CONFIRM_GE(count,1);
for (j=0; j<count; ++j)
{
char buf[32];
expected_string = base;
expected_string += itoa(j,buf);
CONFIRM_EQ(array.getNextString(status),expected_string);
}
}
else
{
CONFIRM_EQ(count,kERROR_COUNT);
// CONFIRM_EQ((int32_t)(unsigned long)array,(int32_t)0);
count = 0;
}
//--------------------------------------------------------------------------
// arrayItem ResourceBundle using the index
for (j=0; j<100; ++j)
{
index = count ? (randi(count * 3) - count) : (randi(200) - 100);
status = U_ZERO_ERROR;
string = kERROR;
ResourceBundle array = theBundle.get(tag, status);
if(!U_FAILURE(status)){
UnicodeString t = array.getStringEx(index, status);
if(!U_FAILURE(status)) {
string=t;
}
}
expected_status = (index >= 0 && index < count) ? expected_resource_status : U_MISSING_RESOURCE_ERROR;
CONFIRM_UErrorCode(status,expected_status);
if (U_SUCCESS(status)){
char buf[32];
expected_string = base;
expected_string += itoa(index,buf);
} else {
expected_string = kERROR;
}
CONFIRM_EQ(string,expected_string);
}
//--------------------------------------------------------------------------
// 2dArray
uprv_strcpy(tag, "array_2d_");
uprv_strcat(tag, frag);
action = param[i].name;
action += ".get(";
action += tag;
action += ")";
int32_t row_count = kERROR_COUNT, column_count = kERROR_COUNT;
status = U_ZERO_ERROR;
ResourceBundle array2d=theBundle.get(tag, status);
//const UnicodeString** array2d = theBundle.get2dArray(tag, row_count, column_count, status);
CONFIRM_UErrorCode(status,expected_resource_status);
if (U_SUCCESS(status))
{
//confirm the resource type is an 2darray
UResType bundleType=array2d.getType();
CONFIRM_EQ(bundleType, RES_ARRAY);
row_count=array2d.getSize();
CONFIRM_GE(row_count,1);
for(row=0; row<row_count; ++row){
ResourceBundle tablerow=array2d.get(row, status);
CONFIRM_UErrorCode(status, expected_resource_status);
if(U_SUCCESS(status)){
//confirm the resourcetype of each table row is an array
UResType rowType=tablerow.getType();
CONFIRM_EQ(rowType, RES_ARRAY);
column_count=tablerow.getSize();
CONFIRM_GE(column_count,1);
for (col=0; j<column_count; ++j) {
char buf[32];
expected_string = base;
expected_string += itoa(row,buf);
expected_string += itoa(col,buf);
CONFIRM_EQ(tablerow.getNextString(status),expected_string);
}
}
}
}else{
CONFIRM_EQ(row_count,kERROR_COUNT);
CONFIRM_EQ(column_count,kERROR_COUNT);
row_count=column_count=0;
}
//--------------------------------------------------------------------------
// 2dArrayItem
for (j=0; j<200; ++j)
{
row = row_count ? (randi(row_count * 3) - row_count) : (randi(200) - 100);
col = column_count ? (randi(column_count * 3) - column_count) : (randi(200) - 100);
status = U_ZERO_ERROR;
string = kERROR;
ResourceBundle array2d=theBundle.get(tag, status);
if(U_SUCCESS(status)){
ResourceBundle tablerow=array2d.get(row, status);
if(U_SUCCESS(status)) {
UnicodeString t=tablerow.getStringEx(col, status);
if(U_SUCCESS(status)){
string=t;
}
}
}
expected_status = (row >= 0 && row < row_count && col >= 0 && col < column_count) ?
expected_resource_status: U_MISSING_RESOURCE_ERROR;
CONFIRM_UErrorCode(status,expected_status);
if (U_SUCCESS(status)){
char buf[32];
expected_string = base;
expected_string += itoa(row,buf);
expected_string += itoa(col,buf);
} else {
expected_string = kERROR;
}
CONFIRM_EQ(string,expected_string);
}
//--------------------------------------------------------------------------
// taggedArray
uprv_strcpy(tag, "tagged_array_");
uprv_strcat(tag, frag);
action = param[i].name;
action += ".get(";
action += tag;
action += ")";
int32_t tag_count;
status = U_ZERO_ERROR;
ResourceBundle tags=theBundle.get(tag, status);
CONFIRM_UErrorCode(status, expected_resource_status);
if (U_SUCCESS(status)) {
UResType bundleType=tags.getType();
CONFIRM_EQ(bundleType, RES_TABLE);
tag_count=tags.getSize();
CONFIRM_GE((int32_t)tag_count, (int32_t)0);
for(index=0; index <tag_count; index++){
ResourceBundle tagelement=tags.get(index, status);
UnicodeString key=tagelement.getKey();
UnicodeString value=tagelement.getNextString(status);
logln("tag = " + key + ", value = " + value );
if(key.startsWith("tag") && value.startsWith(base)){
record_pass();
}else{
record_fail();
}
}
}else{
tag_count=0;
}
//--------------------------------------------------------------------------
// taggedArrayItem
action = param[i].name;
action += ".get(";
action += tag;
action += ")";
count = 0;
for (index=-20; index<20; ++index)
{
char buf[32];
status = U_ZERO_ERROR;
string = kERROR;
char item_tag[6];
uprv_strcpy(item_tag, "tag");
uprv_strcat(item_tag, itoa(index,buf));
ResourceBundle tags=theBundle.get(tag, status);
if(U_SUCCESS(status)){
ResourceBundle tagelement=tags.get(item_tag, status);
if(!U_FAILURE(status)){
UResType elementType=tagelement.getType();
CONFIRM_EQ(elementType, RES_STRING);
const char* key=tagelement.getKey();
CONFIRM_EQ((UnicodeString)key, (UnicodeString)item_tag);
UnicodeString t=tagelement.getString(status);
if(!U_FAILURE(status)){
string=t;
}
}
if (index < 0) {
CONFIRM_UErrorCode(status,U_MISSING_RESOURCE_ERROR);
}
else{
if (status != U_MISSING_RESOURCE_ERROR) {
count++;
expected_string = base;
expected_string += buf;
CONFIRM_EQ(string,expected_string);
}
}
}
}
CONFIRM_EQ(count, tag_count);
}
return pass;
}
void
NewResourceBundleTest::record_pass()
{
++pass;
}
void
NewResourceBundleTest::record_fail()
{
err();
++fail;
}
//eof

44
icu4c/source/test/intltest/restsnew.h Normal file
View file

@ -0,0 +1,44 @@
/********************************************************************
* COPYRIGHT:
* Copyright (c) 1997-1999, International Business Machines Corporation and
* others. All Rights Reserved.
********************************************************************/
#include "intltest.h"
/**
* Tests for class ResourceBundle
**/
class NewResourceBundleTest: public IntlTest {
public:
NewResourceBundleTest();
~NewResourceBundleTest();
void runIndexedTest( int32_t index, bool_t exec, char* &name, char* par = NULL );
/**
* Perform several extensive tests using the subtest routine testTag
**/
void TestResourceBundles(void);
/**
* Test construction of ResourceBundle accessing a custom test resource-file
**/
void TestConstruction(void);
void TestIteration(void);
private:
/**
* extensive subtests called by TestResourceBundles
**/
bool_t testTag(const char* frag, bool_t in_Root, bool_t in_te, bool_t in_te_IN);
void record_pass(void);
void record_fail(void);
int32_t pass;
int32_t fail;
IntlTest& OUT;
};

24
icu4c/source/tools/Makefile.in
View file

@ -119,19 +119,27 @@ include $(srcdir)/makeconv/ucmfiles.mk
-include $(srcdir)/makeconv/ucmlocal.mk
ALL_UCM_SOURCE= $(UCM_SOURCE) $(UCM_SOURCE_LOCAL)
include $(srcdir)/genrb/genrbfiles.mk
-include $(srcdir)/genrb/reslocal.mk
ALL_RES_SOURCE= $(GENRB_SOURCE) $(TRANSLIT_SOURCE) $(RESOURCE_SRC) $(RES_SOURCE_LOCAL)
UCM_FILES = $(ALL_UCM_SOURCE:%=$(top_srcdir)/../data/%)
CNV_FILES = $(ALL_UCM_SOURCE:%.ucm=$(OBJDATADIR)/%.cnv)
RES_SRC_FILES = $(ALL_RES_SOURCE:%=$(top_srcdir)/../data/%)
RES_FILES = $(ALL_RES_SOURCE:%.txt=$(OBJDATADIR)/%.res)
DATAFILESC=$(CNV_FILES)
DATAFILESR=$(RES_FILES)
DATAFILES=$(DATAFILESD) $(DATAFILESC) $(DATAFILESB)
DATAFILES=$(DATAFILESD) $(DATAFILESC) $(DATAFILESB) $(DATAFILESR)
SRCDATAFILESD=$(DATAFILESD:%.dat=%_dat.c)
SRCDATAFILESR=$(DATAFILESR:%.res=%_res.c)
SRCDATAFILESC=$(DATAFILESC:%.cnv=%_cnv.c)
SRCDATAFILESB=$(DATAFILESB:%.brk=%_brk.c)
SRCDATAFILES=$(SRCDATAFILESD) $(SRCDATAFILESC) $(SRCDATAFILESB) $(OBJDATADIR)/icudata_dat.c
SRCDATAFILES=$(SRCDATAFILESD) $(SRCDATAFILESC) $(SRCDATAFILESB) $(SRCDATAFILESR) $(OBJDATADIR)/icudata_dat.c
OBJDATAFILES=$(SRCDATAFILES:%.c=%.o)
@ -147,9 +155,12 @@ TESTDATADLL=$(OBJDATADIR)/libtest_dat.$(SO)
BASEDATADLL=$(OBJDATADIR)/libbase_dat.$(SO)
BASETESTDATADLL=$(OBJDATADIR)/libbase_test_dat.$(SO)
blah:
echo $(SRCDATAFILES)
BASETESTDATA=base_test.dat
build-basetestdata:
@echo Generating the base test data file (base_test.dat) from (test.dat)
@echo Generating the base test data file base_test.dat from test.dat
@cp $(TESTDATAD) $(SRCDATADIR)/$(BASETESTDATA)
@ls -l $(SRCDATADIR)/$(BASETESTDATA)
@ -182,7 +193,7 @@ gencmn/mkmap.tmp: Makefile $(DATAFILES)
$(COMMONFILE): $(DATAFILES) gencmn/mkmap.tmp
@echo -n Generating common file $(COMMONFILE). Number of files:
@echo -n Generating common file $(COMMONFILE). Number of files: Objdata dir is $(OBJDATADIR)
-@wc -l gencmn/mkmap.tmp
-rm -f $(COMMONFILE)
(cd gencmn ; ./gencmn -c -d ../$(OBJDATADIR) 1000000 mkmap.tmp )
@ -201,6 +212,9 @@ build-testdlls: $(TESTDATADLL) $(BASEDATADLL) $(BASETESTDATADLL)
%_brk.c: %.brk
(cd genccode ; ./genccode ../$< )
%_res.c: %.res
(cd genccode ; ./genccode ../$< )
## Note: this generates a dummy C++ file to cause the HPUX CC linker
## to load exception handling (when requested..)

76
icu4c/source/tools/genrb/Makefile.in
View file

@ -55,43 +55,49 @@ LDFLAGS = @LDFLAGS@ \
$(LD_RPATH)$(LD_RPATH_PRE)$(libdir)@ld_rpath_suf@$(LD_RPATH_PRE)$(top_builddir)/common@ld_rpath_suf@$(LD_RPATH_PRE)$(top_builddir)/i18n@ld_rpath_suf@$(LD_RPATH_PRE)$(top_builddir)/tools/toolutil@ld_rpath_suf@$(LD_RPATH_PRE)$(top_builddir)/extra/ustdio
LIBS = $(LIBICU-UC) $(LIBICU-I18N) @LIBS@ @LIB_M@ $(LIBICU-TOOLUTIL) $(LIBUSTDIO)
OBJECTS = error.o genrb.o ustr.o parse.o read.o write.o list.o \
rblist.o util.o
##OBJECTS = error.o genrb.o ustr.o parse.o read.o write.o list.o \
##rblist.o util.o
OBJECTS = error.o genrb.o parse.o read.o reslist.o ustr.o util.o
DEPS = $(OBJECTS:.o=.d)
## List of resource bundles to build
TXT_SOURCE = ar.txt ar_AE.txt ar_BH.txt ar_DZ.txt ar_EG.txt ar_IQ.txt \
ar_JO.txt ar_KW.txt ar_LB.txt ar_LY.txt ar_MA.txt ar_OM.txt ar_QA.txt \
ar_SA.txt ar_SD.txt ar_SY.txt ar_TN.txt ar_YE.txt be.txt be_BY.txt \
bg.txt bg_BG.txt ca.txt ca_ES.txt ca_ES_EURO.txt cs.txt cs_CZ.txt \
da.txt da_DK.txt de.txt de_AT.txt de_AT_EURO.txt de_CH.txt de_DE.txt \
de_DE_EURO.txt de_LU.txt de_LU_EURO.txt el.txt el_GR.txt en.txt \
en_AU.txt en_BE.txt en_CA.txt en_GB.txt en_IE.txt en_IE_EURO.txt \
en_NZ.txt en_US.txt en_ZA.txt es.txt es_AR.txt es_BO.txt es_CL.txt \
es_CO.txt es_CR.txt es_DO.txt es_EC.txt es_ES.txt es_ES_EURO.txt \
es_GT.txt es_HN.txt es_MX.txt es_NI.txt es_PA.txt es_PE.txt es_PR.txt \
es_PY.txt es_SV.txt es_UY.txt es_VE.txt et.txt et_EE.txt fi.txt \
fi_FI.txt fi_FI_EURO.txt fr.txt fr_BE.txt fr_BE_EURO.txt fr_CA.txt \
fr_CH.txt fr_FR.txt fr_FR_EURO.txt fr_LU.txt fr_LU_EURO.txt hr.txt \
hr_HR.txt hu.txt hu_HU.txt is.txt is_IS.txt it.txt it_CH.txt it_IT.txt \
it_IT_EURO.txt iw.txt iw_IL.txt ja.txt ja_JP.txt ko.txt ko_KR.txt \
lt.txt lt_LT.txt lv.txt lv_LV.txt mk.txt mk_MK.txt nl.txt nl_BE.txt \
nl_BE_EURO.txt nl_NL.txt nl_NL_EURO.txt no.txt no_NO.txt no_NO_NY.txt \
pl.txt pl_PL.txt pt.txt pt_BR.txt pt_PT.txt pt_PT_EURO.txt ro.txt \
ro_RO.txt ru.txt ru_RU.txt sh.txt sh_YU.txt sk.txt sk_SK.txt sl.txt \
sl_SI.txt sq.txt sq_AL.txt sr.txt sr_YU.txt sv.txt sv_SE.txt th.txt \
th_TH.txt tr.txt tr_TR.txt uk.txt uk_UA.txt vi.txt vi_VN.txt zh.txt \
zh_CN.txt zh_HK.txt zh_TW.txt default.txt index.txt
include genrbfiles.mk
-include reslocal.mk
TRANSLIT_SOURCE = kbdescl1.txt larabic.txt ldevan.txt \
lgreek.txt fullhalf.txt lhebrew.txt lkana.txt lcyril.txt \
quotes.txt ucname.txt index.txt ljamo.txt
## List of resource bundles to build
TXT_SOURCE = $(GENRB_SOURCE) $(TRANSLIT_SOURCE)
#TXT_SOURCE = ar.txt ar_AE.txt ar_BH.txt ar_DZ.txt ar_EG.txt ar_IQ.txt \
#ar_JO.txt ar_KW.txt ar_LB.txt ar_LY.txt ar_MA.txt ar_OM.txt ar_QA.txt \
#ar_SA.txt ar_SD.txt ar_SY.txt ar_TN.txt ar_YE.txt be.txt be_BY.txt \
#bg.txt bg_BG.txt ca.txt ca_ES.txt ca_ES_EURO.txt cs.txt cs_CZ.txt \
#da.txt da_DK.txt de.txt de_AT.txt de_AT_EURO.txt de_CH.txt de_DE.txt \
#de_DE_EURO.txt de_LU.txt de_LU_EURO.txt el.txt el_GR.txt en.txt \
#en_AU.txt en_BE.txt en_CA.txt en_GB.txt en_IE.txt en_IE_EURO.txt \
#en_NZ.txt en_US.txt en_ZA.txt es.txt es_AR.txt es_BO.txt es_CL.txt \
#es_CO.txt es_CR.txt es_DO.txt es_EC.txt es_ES.txt es_ES_EURO.txt \
#es_GT.txt es_HN.txt es_MX.txt es_NI.txt es_PA.txt es_PE.txt es_PR.txt \
#es_PY.txt es_SV.txt es_UY.txt es_VE.txt et.txt et_EE.txt fi.txt \
#fi_FI.txt fi_FI_EURO.txt fr.txt fr_BE.txt fr_BE_EURO.txt fr_CA.txt \
#fr_CH.txt fr_FR.txt fr_FR_EURO.txt fr_LU.txt fr_LU_EURO.txt hr.txt \
#hr_HR.txt hu.txt hu_HU.txt is.txt is_IS.txt it.txt it_CH.txt it_IT.txt \
#it_IT_EURO.txt iw.txt iw_IL.txt ja.txt ja_JP.txt ko.txt ko_KR.txt \
#lt.txt lt_LT.txt lv.txt lv_LV.txt mk.txt mk_MK.txt nl.txt nl_BE.txt \
#nl_BE_EURO.txt nl_NL.txt nl_NL_EURO.txt no.txt no_NO.txt no_NO_NY.txt \
#pl.txt pl_PL.txt pt.txt pt_BR.txt pt_PT.txt pt_PT_EURO.txt ro.txt \
#ro_RO.txt ru.txt ru_RU.txt sh.txt sh_YU.txt sk.txt sk_SK.txt sl.txt \
#sl_SI.txt sq.txt sq_AL.txt sr.txt sr_YU.txt sv.txt sv_SE.txt th.txt \
#th_TH.txt tr.txt tr_TR.txt uk.txt uk_UA.txt vi.txt vi_VN.txt zh.txt \
#zh_CN.txt zh_HK.txt zh_TW.txt root.txt index.txt
#TRANSLIT_SOURCE = kbdescl1.txt larabic.txt ldevan.txt \
#lgreek.txt fullhalf.txt lhebrew.txt lkana.txt lcyril.txt \
#quotes.txt ucname.txt index.txt ljamo.txt
TXT_FILES = $(TXT_SOURCE:%=$(top_srcdir)/../data/%)
RES_FILES = $(TXT_FILES:$(top_srcdir)/../data/%.txt=@DATABUILDDIR@/%.res)
TRANSLIT_FILES = $(TRANSLIT_SOURCE:%=$(top_srcdir)/../data/translit/%)
TRANSLIT_RES = $(TRANSLIT_SOURCE:%.txt=@DATABUILDDIR@/translit/%.res)
#TRANSLIT_FILES = $(TRANSLIT_SOURCE:%=$(top_srcdir)/../data/translit/%)
#TRANSLIT_RES = $(TRANSLIT_SOURCE:%.txt=@DATABUILDDIR@/translit/%.res)
TEST_FILES = @DATABUILDDIR@/../source/test/testdata/default.res \
@DATABUILDDIR@/../source/test/testdata/te.res \
@DATABUILDDIR@/../source/test/testdata/te_IN.res
@ -151,15 +157,15 @@ $(TARGET) : $(OBJECTS)
@DATABUILDDIR@/../source/test/testdata/%.res : $(top_srcdir)/test/testdata/%.txt
@echo "Creating testdata resource file for $<"
@ICU_DATA=@DATABUILDDIR@ ./genrb -D@DATABUILDDIR@/../source/test/testdata/ $<
@ICU_DATA=@DATABUILDDIR@ ./genrb -d@DATABUILDDIR@/../source/test/testdata/ $<
@DATABUILDDIR@/translit/%.res : $(top_srcdir)/../data/translit/%.txt
@echo "Creating translit resource file for $<"
@ICU_DATA=@DATABUILDDIR@ ./genrb -D@DATABUILDDIR@/translit/ $<
#@DATABUILDDIR@/translit/%.res : $(top_srcdir)/../data/translit/%.txt
# @echo "Creating translit resource file for $<"
# @ICU_DATA=@DATABUILDDIR@ ./genrb -d@DATABUILDDIR@/translit/ $<
@DATABUILDDIR@/%.res : $(top_srcdir)/../data/%.txt
@echo "Creating compiled resource file for $<"
@ICU_DATA=@DATABUILDDIR@ ./genrb -D@DATABUILDDIR@/ $<
@ICU_DATA=@DATABUILDDIR@ ./genrb -d@DATABUILDDIR@/ $<
# the 'mv' will always fail if you are building in the source dir

250
icu4c/source/tools/genrb/genrb.c
View file

@ -26,11 +26,12 @@ U_CDECL_BEGIN
#include "error.h"
#include "parse.h"
#include "write.h"
#include "util.h"
#include "reslist.h"
U_CDECL_END
#include "toolutil.h"
#include "uoptions.h"
#include "unicode/ucol.h"
#include "unicode/uloc.h"
@ -38,7 +39,7 @@ U_CDECL_END
/* Protos */
static void usage(void);
static void version(void);
static void processFile(const char *filename, const char* cp, const char *outputDir, UErrorCode *status);
static void processFile(const char *filename, const char* cp, const char *inputDir, const char *outputDir, UErrorCode *status);
static char* make_res_filename(const char *filename, const char *outputDir, UErrorCode *status);
static char* make_col_filename(const char *filename, const char *outputDir, UErrorCode *status);
static void make_col(const char *filename, UErrorCode *status);
@ -49,9 +50,29 @@ int main(int argc, char **argv);
#define COL_SUFFIX ".col"
/* The version of genrb */
#define GENRB_VERSION "1.0"
#define GENRB_VERSION "2.0"
static enum {
HELP1,
HELP2,
VERBOSE,
VERSION,
SOURCEDIR,
DESTDIR,
ENCODING
};
static UOption options[]={
UOPTION_HELP_H,
UOPTION_HELP_QUESTION_MARK,
UOPTION_VERBOSE,
UOPTION_VERSION,
UOPTION_SOURCEDIR,
UOPTION_DESTDIR,
UOPTION_ENCODING
};
const char *encoding = "";
int
@ -63,133 +84,134 @@ main(int argc,
int useConversionLibrary = 0;
int optind = 1;
int i;
const char *arg;
UErrorCode status;
const char *arg = NULL;
const char *outputDir = NULL; /* NULL = no output directory, use current */
const char *inputDir = NULL;
const char *encoding = "";
bool_t verbose;
argc = u_parseArgs(argc, argv, sizeof(options)/sizeof(options[0]), options);
if(argc == 1)
printUsage = 1;
/* parse the options */
for(optind = 1; optind < argc; ++optind) {
arg = argv[optind];
/* version info */
if(uprv_strcmp(arg, "-v") == 0 || uprv_strcmp(arg, "--version") == 0) {
printVersion = 1;
}
/* usage info */
else if(uprv_strcmp(arg, "-h") == 0 || uprv_strcmp(arg, "--help") == 0) {
printUsage = 1;
}
else if(uprv_strncmp(arg, "-e", 2) == 0) {
useConversionLibrary = 1;
if(uprv_strlen(arg) > uprv_strlen("-e")) {
encoding = arg+2;
} else {
encoding = 0;
}
}
else if(uprv_strncmp(arg, "-D", 2) == 0) {
outputDir = arg+2;
}
/* POSIX.1 says all arguments after -- are not options */
else if(uprv_strcmp(arg, "--") == 0) {
/* skip the -- */
++optind;
break;
}
/* unrecognized option */
else if(uprv_strncmp(arg, "-", uprv_strlen("-")) == 0) {
printf("genrb: invalid option -- %s\n", arg+1);
printUsage = 1;
}
/* done with options, start file processing */
else {
break;
}
/* error handling, printing usage message */
if(argc<0) {
fprintf(stderr, "error in command line argument \"%s\"\n", argv[-argc]);
} else if(argc<2) {
argc=-1;
}
/* print usage info */
if(printUsage) {
usage();
return 0;
if(argc<0 || options[HELP1].doesOccur || options[HELP2].doesOccur) {
fprintf(stderr,
"Usage: %s [OPTIONS] [FILES]\n"
"\treads the list of resource bundle source files and creates\n"
"\tbinary version of reosurce bundles (.res files)\n"
"\tOptions:\n"
"\t\t-h, -? or --help this usage text\n"
"\t\t-V or --version prints out version number and exits\n"
"\t\t-d of --destdir destination directory, followed by the path, defaults to %s\n"
"\t\t-v or --verbose be verbose\n"
"\t\t-e or --encoding encoding of source files, leave empty for system default encoding\n"
"\t\t NOTE: ICU must be completely built to use this option\n"
"\t\t-s or --sourcedir source directory for files followed by path, defaults to %s\n",
argv[0], u_getDataDirectory(), u_getDataDirectory());
return argc<0 ? U_ILLEGAL_ARGUMENT_ERROR : U_ZERO_ERROR;
}
/* print version info */
if(printVersion) {
version();
return 0;
if(options[VERSION].doesOccur) {
fprintf(stderr,
"%s version %s (ICU version %s).\n"
"%s\n",
argv[0], GENRB_VERSION, U_ICU_VERSION, U_COPYRIGHT_STRING);
return U_ZERO_ERROR;
}
if(options[VERBOSE].doesOccur) {
verbose = TRUE;
}
if(options[SOURCEDIR].doesOccur) {
inputDir = options[SOURCEDIR].value;
}
if(options[DESTDIR].doesOccur) {
outputDir = options[DESTDIR].value;
}
if(options[ENCODING].doesOccur) {
encoding = options[ENCODING].value;
}
/* generate the binary files */
for(i = optind; i < argc; ++i) {
for(i = 1; i < argc; ++i) {
status = U_ZERO_ERROR;
arg = getLongPathname(argv[i]);
processFile(arg, encoding, outputDir, &status);
make_col(arg, &status);
/*
if(outputDir == NULL) {
char *pathSepPosition = NULL;
pathSepPosition = uprv_strrchr(arg, U_FILE_SEP_CHAR);
if(pathSepPosition != NULL) {
int32_t pathLen = pathSepPosition-arg+1;
outputDir = (char *) uprv_malloc(sizeof(char)*(pathLen+1));
uprv_strncpy(outputDir, arg, pathLen);
outputDir[pathLen] = '\0';
}
}
*/
printf("genrb: processing file \"%s\"\n", arg);
processFile(arg, encoding, inputDir, outputDir, &status);
/*make_col(arg, &status);*/
if(U_FAILURE(status)) {
printf("genrb: %s processing file \"%s\"\n", u_errorName(status), arg);
if(getErrorText() != 0)
printf(" (%s)\n", getErrorText());
printf("genrb: %s processing file \"%s\"\n", u_errorName(status), arg);
if(getErrorText() != 0)
printf(" (%s)\n", getErrorText());
}
}
return 0;
}
/* Usage information */
static void
usage()
{
puts("Usage: genrb [OPTIONS] [FILES]");
puts("Options:");
puts(" -e Resource bundle is encoded with system default encoding");
puts(" -eEncoding Resource bundle uses specified Encoding");
puts(" -h, --help Print this message and exit.");
puts(" -v, --version Print the version number of genrb and exit.");
puts(" -Ddir Store ALL output files under 'dir'.");
encoding!=NULL?puts(encoding):puts("encoding is NULL");
}
/* Version information */
static void
version()
{
printf("genrb version %s (ICU version %s).\n",
GENRB_VERSION, U_ICU_VERSION);
puts(U_COPYRIGHT_STRING);
return status;
}
/* Process a file */
static void
processFile(const char *filename, const char *cp, const char *outputDir,
UErrorCode *status)
processFile(const char *filename, const char *cp, const char *inputDir, const char *outputDir, UErrorCode *status)
{
FileStream *in;
FileStream *rb_out;
struct SRBItemList *data;
struct SRBRoot *data;
char *rbname;
if(U_FAILURE(*status)) return;
/* Setup */
in = rb_out = 0;
in = 0;
/* Open the input file for reading */
in = T_FileStream_open(filename, "r");
if(inputDir == NULL) {
in = T_FileStream_open(filename, "r");
} else {
char *openFileName = NULL;
int32_t dirlen = uprv_strlen(inputDir);
int32_t filelen = uprv_strlen(filename);
if(inputDir[dirlen-1] != U_FILE_SEP_CHAR) {
openFileName = (char *) uprv_malloc(dirlen+filelen+2);
uprv_strcpy(openFileName, inputDir);
openFileName[dirlen] = U_FILE_SEP_CHAR;
openFileName[dirlen+1] = '\0';
uprv_strcat(openFileName, filename);
} else {
openFileName = (char *) uprv_malloc(dirlen+filelen+1);
uprv_strcpy(openFileName, inputDir);
uprv_strcat(openFileName, filename);
}
in = T_FileStream_open(openFileName, "r");
uprv_free(openFileName);
}
if(in == 0) {
*status = U_FILE_ACCESS_ERROR;
setErrorText("File not found");
return;
}
/* Parse the data into an SRBItemList */
/* Parse the data into an SRBRoot */
data = parse(in, cp, status);
/* Determine the target rb filename */
@ -199,22 +221,17 @@ processFile(const char *filename, const char *cp, const char *outputDir,
}
/* Open the target file for writing */
rb_out = T_FileStream_open(rbname, "wb");
if(rb_out == 0 || T_FileStream_error(rb_out) != 0) {
*status = U_FILE_ACCESS_ERROR;
setErrorText("Could not open file for writing");
goto finish;
}
/* Write the data to the file */
rb_write(rb_out, data, status);
/*rb_write(rb_out, data, status);*/
bundle_write(data, outputDir, status);
/*bundle_write(data, outputDir, rbname, status);*/
bundle_close(data, status);
finish:
/* Clean up */
rblist_close(data, status);
T_FileStream_close(in);
T_FileStream_close(rb_out);
uprv_free(rbname);
}
@ -261,22 +278,29 @@ make_res_filename(const char *filename,
}
uprv_strcpy(resName, dirname);
uprv_strcat(resName, basename);
uprv_strcat(resName, RES_SUFFIX);
/*uprv_strcat(resName, RES_SUFFIX);*/
}
else
{
/* output in 'outputDir' */
resName = (char*) uprv_malloc(sizeof(char) * (uprv_strlen(outputDir)
+ uprv_strlen(basename)
+ uprv_strlen(RES_SUFFIX) + 1));
int32_t dirlen = uprv_strlen(outputDir);
int32_t dirnamelen = uprv_strlen(dirname);
int32_t basenamelen = uprv_strlen(basename);
resName = (char*) uprv_malloc(sizeof(char) * (dirlen + basenamelen + 2));
/*resName = (char*) uprv_malloc(sizeof(char) * (dirnamelen + basenamelen + 1));*/
if(resName == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
goto finish;
}
uprv_strcpy(resName, outputDir);
uprv_strcat(resName, basename);
uprv_strcat(resName, RES_SUFFIX);
if(outputDir[dirlen] != U_FILE_SEP_CHAR) {
resName[dirlen] = U_FILE_SEP_CHAR;
resName[dirlen+1] = '\0';
}
/*uprv_strcat(resName, dirname);*/
/*uprv_strcpy(resName, dirname);*/
uprv_strcat(resName, basename);
}
finish:

26
icu4c/source/tools/genrb/genrb.dsp
View file

@ -74,7 +74,7 @@ BSC32=bscmake.exe
# ADD BSC32 /nologo
LINK32=link.exe
# ADD BASE LINK32 kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept
# ADD LINK32 ..\..\..\lib\debug\icui18n.lib ..\..\..\lib\debug\icuuc.lib toolutil.lib kernel32.lib user32.lib gdi32.lib winspool.lib comdlg32.lib advapi32.lib shell32.lib ole32.lib oleaut32.lib uuid.lib odbc32.lib odbccp32.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\toolutil\Debug"
# ADD LINK32 icui18n.lib icuuc.lib ustdio.lib toolutil.lib /nologo /subsystem:console /debug /machine:I386 /pdbtype:sept /libpath:"..\toolutil\Debug" /libpath:"..\..\..\lib\debug\\"
!ENDIF
@ -95,19 +95,15 @@ SOURCE=.\genrb.c
# End Source File
# Begin Source File
SOURCE=.\list.c
# End Source File
# Begin Source File
SOURCE=.\parse.c
# End Source File
# Begin Source File
SOURCE=.\rblist.c
SOURCE=.\read.c
# End Source File
# Begin Source File
SOURCE=.\read.c
SOURCE=.\reslist.c
# End Source File
# Begin Source File
@ -117,10 +113,6 @@ SOURCE=.\ustr.c
SOURCE=.\util.c
# End Source File
# Begin Source File
SOURCE=.\write.c
# End Source File
# End Group
# Begin Group "Header Files"
@ -131,19 +123,15 @@ SOURCE=.\error.h
# End Source File
# Begin Source File
SOURCE=.\list.h
# End Source File
# Begin Source File
SOURCE=.\parse.h
# End Source File
# Begin Source File
SOURCE=.\rblist.h
SOURCE=.\read.h
# End Source File
# Begin Source File
SOURCE=.\read.h
SOURCE=.\reslist.h
# End Source File
# Begin Source File
@ -153,10 +141,6 @@ SOURCE=.\ustr.h
SOURCE=.\util.h
# End Source File
# Begin Source File
SOURCE=.\write.h
# End Source File
# End Group
# Begin Group "Resource Files"

27
icu4c/source/tools/genrb/genrb.dsw
View file

@ -9,6 +9,33 @@ Package=<5>
{{{
}}}
Package=<4>
{{{
Begin Project Dependency
Project_Dep_Name testgenrb
End Project Dependency
}}}
###############################################################################
Project: "test"=.\test\test.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}
###############################################################################
Project: "testgenrb"=.\testgenrb\testgenrb.dsp - Package Owner=<4>
Package=<5>
{{{
}}}
Package=<4>
{{{
}}}

160
icu4c/source/tools/genrb/list.c
View file

@ -17,6 +17,7 @@
#include "list.h"
#include "cmemory.h"
#include "cstring.h"
#include "unicode/ustring.h"
/* Protos */
@ -348,11 +349,12 @@ taglist_open(UErrorCode *status)
list->fType = eTaggedList;
list->u.fTaggedList.fData = 0;
/*list->u.fTaggedList.fData = 0;*/
list->u.fTaggedList.fFirst = NULL;
list->u.fTaggedList.fCount = 0;
list->u.fTaggedList.fCapacity = 32;
/*list->u.fTaggedList.fCapacity = 32;*/
taglist_grow(list, status);
/*taglist_grow(list, status);*/
return list;
}
@ -361,102 +363,120 @@ void
taglist_close(struct SList *list,
UErrorCode *status)
{
if(U_FAILURE(*status)) return;
struct SStringPair *current;
struct SStringPair *prev;
if(U_FAILURE(*status)) return;
if(list->fType != eTaggedList) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
current = list->u.fTaggedList.fFirst;
while(current != NULL) {
prev = current;
current = current->fNext;
uprv_free(prev);
}
uprv_free(list->u.fTaggedList.fData);
/*uprv_free(list->u.fTaggedList.fData);*/
list->fType = eEmpty;
uprv_free(list);
}
static void
taglist_grow(struct SList *list,
UErrorCode *status)
{
int32_t i;
int32_t newCapacity;
struct SStringPair *newData;
if(U_FAILURE(*status)) return;
if(list->fType != eTaggedList) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
newCapacity = list->u.fTaggedList.fCapacity << 1;
/* allocate space for the array of string pairs */
newData = (struct SStringPair*)
uprv_malloc(sizeof(struct SStringPair) * newCapacity);
if(newData == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
return;
}
/* copy each string pair */
for(i = 0; i < list->u.fTaggedList.fCount; ++i) {
newData[i] = list->u.fTaggedList.fData[i];
}
uprv_free(list->u.fTaggedList.fData);
list->u.fTaggedList.fData = newData;
list->u.fTaggedList.fCapacity = newCapacity;
}
void
taglist_add(struct SList *list,
const UChar *tag,
const UChar *data,
UErrorCode *status)
{
int32_t index;
struct SStringPair pair;
/*int32_t index;*/
struct SStringPair *pair = NULL;
struct SStringPair *current = NULL;
struct SStringPair *prev = NULL;
if(U_FAILURE(*status)) return;
if(list->fType != eTaggedList) {
*status = U_ILLEGAL_ARGUMENT_ERROR;
return;
}
pair.fKey = (UChar*) uprv_malloc(sizeof(UChar) * (u_strlen(tag) + 1));
if(pair.fKey == 0) {
pair = (struct SStringPair *) uprv_malloc(sizeof(struct SStringPair));
if(pair->fKey == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
return;
}
pair.fValue = (UChar*) uprv_malloc(sizeof(UChar) * (u_strlen(data) + 1));
if(pair.fValue == 0) {
pair->fKey = (char*) uprv_malloc(sizeof(char) * (u_strlen(tag) + 1));
if(pair->fKey == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
uprv_free(pair.fKey);
uprv_free(pair);
return;
}
pair->fValue = (UChar*) uprv_malloc(sizeof(UChar) * (u_strlen(data) + 1));
if(pair->fValue == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
uprv_free(pair->fKey);
uprv_free(pair);
return;
}
u_strcpy(pair.fKey, tag);
u_strcpy(pair.fValue, data);
index = list->u.fTaggedList.fCount;
if(list->u.fTaggedList.fCount == list->u.fTaggedList.fCapacity)
taglist_grow(list, status);
list->u.fTaggedList.fData[index] = pair;
++(list->u.fTaggedList.fCount);
/*u_strcpy(pair.fKey, tag);*/
u_UCharsToChars(tag, pair->fKey, u_strlen(tag)+1);
u_strcpy(pair->fValue, data);
/* is list still empty? */
if(list->u.fTaggedList.fFirst == NULL) {
list->u.fTaggedList.fFirst = pair;
pair->fNext = NULL;
return;
} else {
current = list->u.fTaggedList.fFirst;
}
while(current != NULL) {
if(uprv_strcmp(current->fKey, pair->fKey)<0) {
prev = current;
current = current->fNext;
} else { /*we're either in front of list, or in middle*/
if(prev == NULL) { /*front of the list*/
list->u.fTaggedList.fFirst = pair;
} else { /*middle of the list*/
prev->fNext = pair;
}
pair->fNext = current;
return;
}
}
/* end of list */
prev->fNext = pair;
pair->fNext = NULL;
/*index = list->u.fTaggedList.fCount;*/
/*if(list->u.fTaggedList.fCount == list->u.fTaggedList.fCapacity)*/
/*taglist_grow(list, status);*/
/*list->u.fTaggedList.fData[index] = pair;*/
}
const UChar*
taglist_get(const struct SList *list,
const UChar *tag,
const char *tag,
UErrorCode *status)
{
int32_t i;
/*int32_t i;*/
struct SStringPair *current;
if(U_FAILURE(*status)) return 0;
@ -465,10 +485,20 @@ taglist_get(const struct SList *list,
return 0;
}
for(i = 0; i < list->u.fTaggedList.fCount; ++i) {
if(u_strcmp(list->u.fTaggedList.fData[i].fKey, tag) == 0)
return list->u.fTaggedList.fData[i].fValue;
}
/* is list still empty? */
if(list->u.fTaggedList.fFirst == NULL) {
return NULL;
} else {
current = list->u.fTaggedList.fFirst;
}
return 0;
while(current != NULL) {
if(uprv_strcmp(current->fKey, tag)!=0) {
current = current->fNext;
} else { /*we're either in front of list, or in middle*/
return current->fValue;
}
}
return NULL;
}

10
icu4c/source/tools/genrb/list.h
View file

@ -49,22 +49,24 @@ void strlist2d_add(struct SList *list, const UChar *s, UErrorCode *status);
/* A name/value pair for a tagged list */
struct SStringPair {
UChar *fKey;
char *fKey;
UChar *fValue;
struct SStringPair *fNext;
};
/* A tagged list */
struct STaggedList {
struct SStringPair *fData;
struct SStringPair *fFirst;
/*struct SStringPair *fData;*/
int32_t fCount;
int32_t fCapacity;
/*int32_t fCapacity;*/
};
struct SList* taglist_open(UErrorCode *status);
void taglist_close(struct SList *list, UErrorCode *status);
void taglist_add(struct SList *list, const UChar *tag,
const UChar *data, UErrorCode *status);
const UChar* taglist_get(const struct SList *list, const UChar *tag,
const UChar* taglist_get(const struct SList *list, const char *tag,
UErrorCode *status);
/* Types of lists */

327
icu4c/source/tools/genrb/parse.c
View file

@ -1,7 +1,7 @@
/*
*******************************************************************************
*
* Copyright (C) 1998-1999, International Business Machines
* Copyright (C) 1998-2000, International Business Machines
* Corporation and others. All Rights Reserved.
*
*******************************************************************************
@ -12,6 +12,7 @@
*
* Date Name Description
* 05/26/99 stephen Creation.
* 02/25/00 weiv Overhaul to write udata
*******************************************************************************
*/
@ -22,8 +23,7 @@
#include "read.h"
#include "unicode/ustdio.h"
#include "ustr.h"
#include "list.h"
#include "rblist.h"
#include "reslist.h"
#include "unicode/ustring.h"
/* Node IDs for the state transition table. */
@ -95,29 +95,29 @@ struct STransition {
comma-delimited list (transition from eList to eIdle on
kCloseBrace). */
static struct STransition gTransitionTable [] = {
/* kString kOpenBrace kCloseBrace kComma*/
{eError,eNOP}, {eError,eNOP}, {eError,eNOP}, {eError,eNOP},
/* kString kOpenBrace kCloseBrace kComma kColon*/
/*eError*/ {eError,eNOP}, {eError,eNOP}, {eError,eNOP}, {eError,eNOP},
{eGotLoc,eOpen}, {eError,eNOP}, {eError,eNOP}, {eError,eNOP},
{eError,eNOP}, {eIdle,eNOP}, {eError,eNOP}, {eError,eNOP},
/*eInitial*/ {eGotLoc,eOpen}, {eError,eNOP}, {eError,eNOP}, {eError,eNOP},
/*eGotLoc*/ {eError,eNOP}, {eIdle,eNOP}, {eError,eNOP}, {eError,eNOP},
/*eIdle*/ {eGotTag,eSetTag}, {eError,eNOP}, {eInitial,eClose}, {eError,eNOP},
/*eGotTag*/ {eError,eNOP}, {eNode5,eNOP}, {eError,eNOP}, {eError,eNOP},
/*eNode5*/ {eNode6,eNOP}, {e2dArray,eBeg2dList},{eError,eNOP}, {eError,eNOP},
/*eNode6*/ {eError,eNOP}, {eTagList,eBegTagged},{eIdle,eStr}, {eList,eBegList},
{eGotTag,eSetTag}, {eError,eNOP}, {eInitial,eClose}, {eError,eNOP},
{eError,eNOP}, {eNode5,eNOP}, {eError,eNOP}, {eError,eNOP},
{eNode6,eNOP}, {e2dArray,eBeg2dList},{eError,eNOP}, {eError,eNOP},
{eError,eNOP}, {eTagList,eBegTagged},{eIdle,eStr}, {eList,eBegList},
{eNode8,eListStr}, {eError,eNOP}, {eIdle,eEndList}, {eError,eNOP},
{eError,eNOP}, {eError,eNOP}, {eIdle,eEndList}, {eList,eNOP},
{eNode10,eTaggedStr},{eError,eNOP}, {eError,eNOP}, {eError,eNOP},
{eError,eNOP}, {eError,eNOP}, {eNode11,eNOP}, {eError,eNOP},
{eNode12,eNOP}, {eError,eNOP}, {eIdle,eEndTagged},{eError,eNOP},
{eError,eNOP}, {eTagList,eSubtag}, {eError,eNOP}, {eError,eNOP},
/*eList*/ {eNode8,eListStr}, {eError,eNOP}, {eIdle,eEndList}, {eError,eNOP},
/*eNode8*/ {eError,eNOP}, {eError,eNOP}, {eIdle,eEndList}, {eList,eNOP},
/*eTagList*/ {eNode10,eTaggedStr},{eError,eNOP}, {eError,eNOP}, {eError,eNOP},
/*eNode10*/ {eError,eNOP}, {eError,eNOP}, {eNode11,eNOP}, {eError,eNOP},
/*eNode11*/ {eNode12,eNOP}, {eError,eNOP}, {eIdle,eEndTagged},{eError,eNOP},
/*eNode12*/ {eError,eNOP}, {eTagList,eSubtag}, {eError,eNOP}, {eError,eNOP},
{eNode14,e2dStr}, {eError,eNOP}, {eNode15,eNOP}, {eError,eNOP},
{eError,eNOP}, {eError,eNOP}, {eNode15,eNOP}, {e2dArray,eNOP},
{eError,eNOP}, {e2dArray,eNewRow}, {eIdle,eEnd2dList},{eNode16,eNOP},
{eError,eNOP}, {e2dArray,eNewRow}, {eIdle,eEnd2dList},{eError,eNOP}
/*e2dArray*/ {eNode14,e2dStr}, {eError,eNOP}, {eNode15,eNOP}, {eError,eNOP},
/*eNode14*/ {eError,eNOP}, {eError,eNOP}, {eNode15,eNOP}, {e2dArray,eNOP},
/*eNode15*/ {eError,eNOP}, {e2dArray,eNewRow}, {eIdle,eEnd2dList},{eNode16,eNOP},
/*eNode16*/ {eError,eNOP}, {e2dArray,eNewRow}, {eIdle,eEnd2dList},{eError,eNOP}
};
/* Row length is 4 */
@ -157,7 +157,7 @@ static bool_t compareUString(const void* ustr1, const void* ustr2) {
* parse
********************************************************************/
struct SRBItemList*
struct SRBRoot*
parse(FileStream *f, const char *cp,
UErrorCode *status)
{
@ -168,36 +168,47 @@ parse(FileStream *f, const char *cp,
struct UString token;
struct UString tag;
struct UString subtag;
struct UString localeName;
struct UString keyname;
struct SRBItem *item;
struct SRBItemList *list;
struct SList *current;
char cTag[1024];
char cSubTag[1024];
struct SRBRoot *bundle = NULL;
struct SResource *rootTable = NULL;
struct SResource *temp = NULL;
struct SResource *temp1 = NULL;
struct SResource *temp2 = NULL;
/* Hashtable for keeping track of seen tag names */
struct UHashtable *data;
/* Hashtable for keeping track of seen tag names */
struct UHashtable *data;
if(U_FAILURE(*status)) return 0;
if(U_FAILURE(*status)) return NULL;
/* setup */
/* setup */
ustr_init(&token);
ustr_init(&tag);
ustr_init(&subtag);
ustr_init(&localeName);
ustr_init(&keyname);
/*
cTag = uprv_malloc(1024);
if(cTag == NULL) {
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
cSubTag = uprv_malloc(1024);
if(cSubTag == NULL) {
*status = U_MEMORY_ALLOCATION_ERROR;
return NULL;
}
*/
node = eInitial;
data = 0;
current = 0;
item = 0;
file = u_finit((FILE *)f, 0, cp);
/* file = u_finit(f, cp, status); */
list = rblist_open(status);
bundle = bundle_open(status);
rootTable = bundle -> fRoot;
if(U_FAILURE(*status) || file == NULL) goto finish;
/* iterate through the stream */
@ -210,7 +221,9 @@ parse(FileStream *f, const char *cp,
switch(type) {
case tok_EOF:
*status = (node == eInitial) ? U_ZERO_ERROR : U_INVALID_FORMAT_ERROR;
setErrorText("Unexpected EOF encountered");
if(U_FAILURE(*status)) {
setErrorText("Unexpected EOF encountered");
}
goto finish;
/*break;*/
@ -227,153 +240,162 @@ parse(FileStream *f, const char *cp,
node = t.fNext;
if(node == eError) {
*status = U_INVALID_FORMAT_ERROR;
goto finish;
*status = U_INVALID_FORMAT_ERROR;
goto finish;
}
switch(t.fAction) {
case eNOP:
break;
break;
/* Record the last string as the tag name */
case eSetTag:
ustr_cpy(&tag, &token, status);
if(U_FAILURE(*status)) goto finish;
if(get(data, &tag)) {
char *s;
*status = U_INVALID_FORMAT_ERROR;
s = uprv_malloc(1024);
strcpy(s, "Duplicate tag name detected: ");
u_austrcpy(s+strlen(s), tag.fChars);
setErrorText(s);
goto finish;
}
break;
ustr_cpy(&tag, &token, status);
u_UCharsToChars(tag.fChars, cTag, u_strlen(tag.fChars)+1);
if(U_FAILURE(*status)) goto finish;
/*if(uhash_get(data, uhash_hashUString(tag.fChars)) != 0) {*/
if(get(data, &tag)) {
char *s;
*status = U_INVALID_FORMAT_ERROR;
s = uprv_malloc(1024);
strcpy(s, "Duplicate tag name detected: ");
u_austrcpy(s+strlen(s), tag.fChars);
setErrorText(s);
goto finish;
}
break;
/* Record a singleton string */
case eStr:
if(current != 0) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
current = strlist_open(status);
strlist_add(current, token.fChars, status);
item = make_rbitem(tag.fChars, current, status);
rblist_add(list, item, status);
put(data, &tag, status);
if(U_FAILURE(*status)) goto finish;
current = 0;
item = 0;
break;
if(temp != NULL) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
temp = string_open(bundle, cTag, token.fChars, status);
table_add(rootTable, temp, status);
/*uhash_put(data, tag.fChars, status);*/
put(data, &tag, status);
if(U_FAILURE(*status)) goto finish;
temp = NULL;
break;
/* Begin a string list */
case eBegList:
if(current != 0) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
current = strlist_open(status);
strlist_add(current, token.fChars, status);
if(U_FAILURE(*status)) goto finish;
break;
if(temp != NULL) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
temp = array_open(bundle, cTag, status);
temp1 = string_open(bundle, NULL, token.fChars, status);
array_add(temp, temp1, status);
temp1 = NULL;
if(U_FAILURE(*status)) goto finish;
break;
/* Record a comma-delimited list string */
case eListStr:
strlist_add(current, token.fChars, status);
if(U_FAILURE(*status)) goto finish;
break;
temp1 = string_open(bundle, NULL, token.fChars, status);
array_add(temp, temp1, status);
temp1 = NULL;
if(U_FAILURE(*status)) goto finish;
break;
/* End a string list */
case eEndList:
put(data, &tag, status);
item = make_rbitem(tag.fChars, current, status);
rblist_add(list, item, status);
if(U_FAILURE(*status)) goto finish;
current = 0;
item = 0;
break;
/*uhash_put(data, tag.fChars, status);*/
put(data, &tag, status);
table_add(rootTable, temp, status);
temp = NULL;
if(U_FAILURE(*status)) goto finish;
break;
case eBeg2dList:
if(current != 0) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
current = strlist2d_open(status);
if(U_FAILURE(*status)) goto finish;
break;
if(temp != NULL) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
temp = array_open(bundle, cTag, status);
temp1 = array_open(bundle, NULL, status);
if(U_FAILURE(*status)) goto finish;
break;
case eEnd2dList:
put(data, &tag, status);
item = make_rbitem(tag.fChars, current, status);
rblist_add(list, item, status);
if(U_FAILURE(*status)) goto finish;
current = 0;
item = 0;
break;
/*uhash_put(data, tag.fChars, status);*/
put(data, &tag, status);
array_add(temp, temp1, status);
table_add(rootTable, temp, status);
temp1 = NULL;
temp = NULL;
if(U_FAILURE(*status)) goto finish;
break;
case e2dStr:
strlist2d_add(current, token.fChars, status);
if(U_FAILURE(*status)) goto finish;
break;
temp2 = string_open(bundle, NULL, token.fChars, status);
array_add(temp1, temp2, status);
temp2 = NULL;
if(U_FAILURE(*status)) goto finish;
break;
case eNewRow:
strlist2d_newRow(current, status);
if(U_FAILURE(*status)) goto finish;
break;
array_add(temp, temp1, status);
temp1 = array_open(bundle, NULL, status);
if(U_FAILURE(*status)) goto finish;
break;
case eBegTagged:
if(current != 0) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
current = taglist_open(status);
ustr_cpy(&subtag, &token, status);
if(U_FAILURE(*status)) goto finish;
break;
if(temp != NULL) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
temp = table_open(bundle, cTag, status);
u_UCharsToChars(token.fChars, cSubTag, u_strlen(token.fChars)+1);
if(U_FAILURE(*status)) goto finish;
break;
case eEndTagged:
put(data, &tag, status);
item = make_rbitem(tag.fChars, current, status);
rblist_add(list, item, status);
if(U_FAILURE(*status)) goto finish;
current = 0;
item = 0;
break;
/*uhash_put(data, tag.fChars, status);*/
put(data, &tag, status);
table_add(rootTable, temp, status);
temp = NULL;
if(U_FAILURE(*status)) goto finish;
break;
case eTaggedStr:
taglist_add(current, subtag.fChars, token.fChars, status);
if(U_FAILURE(*status)) goto finish;
break;
temp1 = string_open(bundle, cSubTag, token.fChars, status);
table_add(temp, temp1, status);
temp1 = NULL;
if(U_FAILURE(*status)) goto finish;
break;
/* Record the last string as the subtag */
case eSubtag:
ustr_cpy(&subtag, &token, status);
if(U_FAILURE(*status)) goto finish;
if(taglist_get(current, subtag.fChars, status) != 0) {
*status = U_INVALID_FORMAT_ERROR;
setErrorText("Duplicate subtag found in tagged list");
goto finish;
}
break;
u_UCharsToChars(token.fChars, cSubTag, u_strlen(token.fChars)+1);
if(U_FAILURE(*status)) goto finish;
if(table_get(temp, cSubTag, status) != 0) {
*status = U_INVALID_FORMAT_ERROR;
setErrorText("Duplicate subtag found in tagged list");
goto finish;
}
break;
case eOpen:
if(data != 0) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
ustr_cpy(&localeName, &token, status);
rblist_setlocale(list, localeName.fChars, status);
if(U_FAILURE(*status)) goto finish;
data = uhash_open(hashUString, compareUString, status);
uhash_setKeyDeleter(data, freeUString);
break;
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
bundle_setlocale(bundle, token.fChars, status);
if(U_FAILURE(*status)) goto finish;
data = uhash_open(hashUString, compareUString, status);
uhash_setKeyDeleter(data, freeUString);
break;
case eClose:
if(data == 0) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
break;
if(data == 0) {
*status = U_INTERNAL_PROGRAM_ERROR;
goto finish;
}
break;
}
}
@ -384,17 +406,14 @@ parse(FileStream *f, const char *cp,
if(data != 0)
uhash_close(data);
if(item != 0)
uprv_free(item);
ustr_deinit(&token);
ustr_deinit(&tag);
ustr_deinit(&subtag);
ustr_deinit(&localeName);
ustr_deinit(&keyname);
/*uprv_free(cTag);*/
/*uprv_free(cSubTag);*/
if(file != 0)
u_fclose(file);
return list;
return bundle;
}

2
icu4c/source/tools/genrb/parse.h
View file

@ -23,6 +23,6 @@
#include "rblist.h"
/* Parse a ResourceBundle text file */
struct SRBItemList* parse(FileStream *f, const char *cp, UErrorCode *status);
struct SRBRoot* parse(FileStream *f, const char *cp, UErrorCode *status);
#endif

160
icu4c/source/tools/genrb/rblist.c
View file

@ -19,17 +19,16 @@
#include "ustr.h"
#include "unicode/ustring.h"
#include "cmemory.h"
#include "cstring.h"
/* Protos */
static void rblist_grow(struct SRBItemList *list, UErrorCode *status);
struct SRBItem*
make_rbitem(const UChar *tag,
const struct SList *data,
UErrorCode *status)
const struct SList *data,
UErrorCode *status)
{
struct SRBItem *item;
UChar *s;
char *s;
if(U_FAILURE(*status)) return 0;
@ -39,15 +38,18 @@ make_rbitem(const UChar *tag,
return 0;
}
s = (UChar*) uprv_malloc(sizeof(UChar) * (u_strlen(tag) + 1));
//s = (UChar*) uprv_malloc(sizeof(UChar) * (u_strlen(tag) + 1));
s = (char*) uprv_malloc(sizeof(char) * (u_strlen(tag) + 1));
if(s == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
return 0;
}
u_strcpy(s, tag);
u_UCharsToChars(tag, s, u_strlen(tag)+1);
//u_strcpy(s, tag);
item->fTag = s;
item->fData = (struct SList*) data;
item->fNext = NULL;
return item;
}
@ -66,58 +68,67 @@ rblist_open(UErrorCode *status)
}
list->fLocale = 0;
list->fFirst = NULL;
list->fData = 0;
// list->fData = 0;
list->fCount = 0;
list->fCapacity = 32;
rblist_grow(list, status);
list->fKeys = (char *) uprv_malloc(sizeof(char) * 65532);
list->fKeyPoint = 0;
return list;
}
void rblist_close(struct SRBItemList *list,
UErrorCode *status)
UErrorCode *status)
{
int32_t i;
// int32_t i;
struct SRBItem *current;
struct SRBItem *prev = NULL;
if(U_FAILURE(*status)) return;
current = list->fFirst;
/* deallocate each list */
for(i = 0; i < list->fCount; ++i) {
// for(i = 0; i < list->fCount; ++i) {
while(current != NULL) {
switch(list->fData[i]->fData->fType) {
case eStringList:
strlist_close(list->fData[i]->fData, status);
break;
// switch(list->fData[i]->fData->fType) {
switch(current->fData->fType) {
case eStringList:
strlist_close(current->fData, status);
break;
case eStringList2d:
strlist2d_close(list->fData[i]->fData, status);
break;
case eStringList2d:
strlist2d_close(current->fData, status);
break;
case eTaggedList:
taglist_close(list->fData[i]->fData, status);
break;
case eTaggedList:
taglist_close(current->fData, status);
break;
case eEmpty:
break;
case eEmpty:
break;
}
prev = current;
current=current->fNext;
uprv_free(prev);
}
uprv_free(list->fData);
// uprv_free(list->fData);
uprv_free(list->fLocale);
uprv_free(list->fKeys);
uprv_free(list);
}
void rblist_setlocale(struct SRBItemList *list,
const UChar *locale,
UErrorCode *status)
const UChar *locale,
UErrorCode *status)
{
if(U_FAILURE(*status)) return;
/* Allocate enough space */
list->fLocale = (UChar*) uprv_realloc(list->fLocale,
sizeof(UChar) * (u_strlen(locale) + 1));
sizeof(UChar) * (u_strlen(locale) + 1));
if(list->fLocale == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
return;
@ -127,48 +138,53 @@ void rblist_setlocale(struct SRBItemList *list,
}
void rblist_add(struct SRBItemList *list,
struct SRBItem *s,
UErrorCode *status)
struct SRBItem *s,
UErrorCode *status)
{
int32_t index;
if(U_FAILURE(*status)) return;
index = list->fCount;
if(list->fCount == list->fCapacity)
rblist_grow(list, status);
list->fData[index] = s;
++(list->fCount);
// int32_t index;
struct SRBItem *current;
struct SRBItem *prev = NULL;
if(U_FAILURE(*status)) return;
/* here we need to traverse the list */
++(list->fCount);
s->fStrKey = list->fKeyPoint;
uprv_strcpy((list->fKeys)+list->fKeyPoint, s->fTag);
list->fKeyPoint += uprv_strlen(s->fTag)+1;
/* is list still empty? */
if(list->fFirst == NULL) {
list->fFirst = s;
s->fNext = NULL;
return;
} else {
current = list->fFirst;
}
while(current != NULL) {
if(uprv_strcmp(current->fTag, s->fTag)<0) {
prev = current;
current = current->fNext;
} else { /*we're either in front of list, or in middle*/
if(prev == NULL) { /*front of the list*/
list->fFirst = s;
} else { /*middle of the list*/
prev->fNext = s;
}
s->fNext = current;
return;
}
}
/* end of list */
prev->fNext = s;
s->fNext = NULL;
}
static void
rblist_grow(struct SRBItemList *list,
UErrorCode *status)
{
int32_t i;
int32_t newCapacity;
struct SRBItem **newData;
if(U_FAILURE(*status)) return;
newCapacity = list->fCapacity << 1;
/* allocate space for the array of SRBItems */
newData = (struct SRBItem**)
uprv_malloc(sizeof(struct SRBItem*) * newCapacity);
if(newData == 0) {
*status = U_MEMORY_ALLOCATION_ERROR;
return;
}
/* copy each item */
for(i = 0; i < list->fCount; ++i) {
newData[i] = list->fData[i];
}
uprv_free(list->fData);
list->fData = newData;
list->fCapacity = newCapacity;
}

15
icu4c/source/tools/genrb/rblist.h
View file

@ -23,22 +23,27 @@
/* A resource bundle data item */
struct SRBItem {
UChar *fTag;
char *fTag;
int16_t fStrKey;
struct SList *fData;
struct SRBItem *fNext;
};
struct SRBItem* make_rbitem(const UChar *tag, const struct SList *data,
UErrorCode *status);
/* A list of RBItems */
struct SRBItemList {
UChar *fLocale;
struct SRBItem **fData;
char *fKeys;
int16_t fKeyPoint;
int32_t fCount;
int32_t fCapacity;
struct SRBItem *fFirst;
};
struct SRBItemList* rblist_open(UErrorCode *status);
struct SRBItem* make_rbitem(const UChar *tag, const struct SList *data,
UErrorCode *status);
void rblist_close(struct SRBItemList *list, UErrorCode *status);
void rblist_setlocale(struct SRBItemList *list, const UChar *locale,

77
icu4c/source/tools/genrb/read.c
View file

@ -18,6 +18,7 @@
#include "read.h"
#include "error.h"
#include "unicode/ustdio.h"
#include "unicode/ustring.h"
#define OPENBRACE 0x007B
#define CLOSEBRACE 0x007D
@ -27,7 +28,17 @@
#define SLASH 0x002F
#define ASTERISK 0x002A
#define SPACE 0x0020
#define COLON 0x003A
U_STRING_DECL(k_start_string, "string", 6);
U_STRING_DECL(k_start_binary, "binary", 6);
U_STRING_DECL(k_start_table, "table", 5);
U_STRING_DECL(k_start_int, "int", 3);
U_STRING_DECL(k_start_array, "array", 5);
U_STRING_DECL(k_start_intvector, "intvector", 9);
U_STRING_DECL(k_start_reserved, "reserved", 8);
static bool_t didInit=FALSE;
/* Protos */
static enum ETokenType getStringToken(UFILE *f, UChar initialChar,
@ -53,21 +64,54 @@ enum ETokenType getNextToken(UFILE *f,
struct UString *token,
UErrorCode *status)
{
UChar c;
if(U_FAILURE(*status)) return tok_error;
UChar c;
/* Skip whitespace */
c = getNextChar(f, TRUE, status);
if(U_FAILURE(*status)) return tok_error;
switch(c) {
case OPENBRACE: return tok_open_brace;
case CLOSEBRACE: return tok_close_brace;
case COMMA: return tok_comma;
case U_EOF: return tok_EOF;
default: return getStringToken(f, c, token, status);
}
enum ETokenType tokenType;
if(U_FAILURE(*status)) return tok_error;
/* Skip whitespace */
c = getNextChar(f, TRUE, status);
if(U_FAILURE(*status)) return tok_error;
switch(c) {
case OPENBRACE: return tok_open_brace;
case CLOSEBRACE: return tok_close_brace;
case COMMA: return tok_comma;
case U_EOF: return tok_EOF;
case COLON:
c = getNextChar(f, TRUE, status);
tokenType = getStringToken(f, c, token, status);
break;
default: return getStringToken(f, c, token, status);
}
if(!didInit) {
U_STRING_INIT(k_start_string, "string", 6);
U_STRING_INIT(k_start_binary, "binary", 6);
U_STRING_INIT(k_start_table, "table", 5);
U_STRING_INIT(k_start_int, "int", 3);
U_STRING_INIT(k_start_array, "array", 5);
U_STRING_INIT(k_start_intvector, "intvector", 9);
U_STRING_INIT(k_start_reserved, "reserved", 8);
didInit=TRUE;
}
if(u_strcmp(token->fChars, k_start_string) == 0) {
return(tok_start_string);
} else if(u_strcmp(token->fChars, k_start_binary) == 0) {
return(tok_start_binary);
} else if(u_strcmp(token->fChars, k_start_table) == 0) {
return(tok_start_table);
} else if(u_strcmp(token->fChars, k_start_int) == 0) {
return(tok_start_int);
} else if(u_strcmp(token->fChars, k_start_array) == 0) {
return(tok_start_array);
} else if(u_strcmp(token->fChars, k_start_intvector) == 0) {
return(tok_start_intvector);
} else if(u_strcmp(token->fChars, k_start_reserved) == 0) {
return(tok_start_reserved);
} else {
return tok_error;
}
}
/* Copy a string token into the given UnicodeString. Upon entry, we
@ -148,7 +192,8 @@ static enum ETokenType getStringToken(UFILE *f,
if(c == QUOTE
|| c == OPENBRACE
|| c == CLOSEBRACE
|| c == COMMA)
|| c == COMMA
|| c == COLON)
{
u_fungetc(c, f);
/*u_fungetc(c, f, status);*/
@ -170,7 +215,7 @@ static enum ETokenType getStringToken(UFILE *f,
if(U_FAILURE(*status))
return tok_string;
if(c == OPENBRACE || c == CLOSEBRACE || c == COMMA) {
if(c == OPENBRACE || c == CLOSEBRACE || c == COMMA || c == COLON) {
u_fungetc(c, f);
/*u_fungetc(c, f, status);*/
return tok_string;

9
icu4c/source/tools/genrb/read.h
View file

@ -29,10 +29,17 @@ enum ETokenType
tok_open_brace, /* An opening brace character */
tok_close_brace, /* A closing brace character */
tok_comma, /* A comma */
tok_start_string, /* :String */
tok_start_binary, /* :Binary */
tok_start_table, /* :Table */
tok_start_int, /* :Integer */
tok_start_array, /* :Array */
tok_start_intvector, /* :IntVector */
tok_start_reserved, /* :Reserved - treat like a string */
tok_EOF, /* End of the file has been reached successfully */
tok_error, /* An error, such an unterminated quoted string */
tok_token_type_count = 4 /* Number of "real" token types */
tok_token_type_count = 11 /* Number of "real" token types */
};
enum ETokenType getNextToken(UFILE *f,

59
icu4c/source/tools/genrb/write.c
View file

@ -27,11 +27,12 @@
/* Protos */
static void write_ustring(FileStream *rb, const UChar *data);
static void write_strlist(FileStream *rb, const UChar *name,
static void write_string(FileStream *rb, const char *data);
static void write_strlist(FileStream *rb, const char *name,
const struct SStringList *list);
static void write_strlist2d(FileStream *rb, const UChar *name,
static void write_strlist2d(FileStream *rb, const char *name,
const struct SStringList2d *list);
static void write_taglist(FileStream *rb, const UChar *name,
static void write_taglist(FileStream *rb, const char *name,
const struct STaggedList *list);
/* Special values */
@ -65,10 +66,21 @@ write_ustring(FileStream *rb,
T_FileStream_write(rb, data, sizeof(UChar) * len);
}
static void
write_string(FileStream *rb,
const char *data) {
int32_t len;
len = uprv_strlen(data);
T_FileStream_write(rb, &len, sizeof(len));
T_FileStream_write(rb, data, sizeof(char) * len);
}
/* Write a string list */
static void
write_strlist(FileStream *rb,
const UChar *name,
const char *name,
const struct SStringList *list)
{
int32_t i;
@ -77,7 +89,7 @@ write_strlist(FileStream *rb,
T_FileStream_write(rb, &sSTRINGLIST, sizeof(sSTRINGLIST));
/* Write the name of this string list */
write_ustring(rb, name);
write_string(rb, name);
/* Write the item count */
T_FileStream_write(rb, &list->fCount, sizeof(list->fCount));
@ -91,7 +103,7 @@ write_strlist(FileStream *rb,
/* Write a 2-d string list */
static void
write_strlist2d(FileStream *rb,
const UChar *name,
const char *name,
const struct SStringList2d *list)
{
int32_t i, j;
@ -101,7 +113,7 @@ write_strlist2d(FileStream *rb,
T_FileStream_write(rb, &sSTRINGLIST2D, sizeof(sSTRINGLIST2D));
/* Write the name of this 2-d string list */
write_ustring(rb, name);
write_string(rb, name);
/* Write the row count */
T_FileStream_write(rb, &list->fRowCount, sizeof(list->fRowCount));
@ -124,25 +136,34 @@ write_strlist2d(FileStream *rb,
/* Write a tagged list */
static void
write_taglist(FileStream *rb,
const UChar *name,
const char *name,
const struct STaggedList *list)
{
int32_t i;
// int32_t i;
struct SStringPair *current;
/* Write out the value indicating this is a tagged list */
T_FileStream_write(rb, &sTAGGEDLIST, sizeof(sTAGGEDLIST));
/* Write the name of this tagged list */
write_ustring(rb, name);
write_string(rb, name);
/* Write the item count */
T_FileStream_write(rb, &list->fCount, sizeof(list->fCount));
/* Write out each key/value pair */
for(i = 0; i < list->fCount; ++i) {
write_ustring(rb, list->fData[i].fKey);
write_ustring(rb, list->fData[i].fValue);
current = list->fFirst;
while(current != NULL) {
write_string(rb, current->fKey);
write_ustring(rb, current->fValue);
current = current->fNext;
}
// for(i = 0; i < list->fCount; ++i) {
// write_ustring(rb, list->fData[i].fKey);
// write_ustring(rb, list->fData[i].fValue);
// }
}
/* Write a parsed SRBItemList to a file */
@ -151,7 +172,7 @@ rb_write(FileStream *f,
struct SRBItemList *data,
UErrorCode *status)
{
int32_t i;
// int32_t i;
struct SRBItem *item;
if(U_FAILURE(*status)) return;
@ -162,10 +183,13 @@ rb_write(FileStream *f,
/* Write the locale name to the file */
write_ustring(f, data->fLocale);
/* Successively write each list item */
for(i = 0; i < data->fCount; ++i) {
item = data->fFirst;
item = data->fData[i];
/* Successively write each list item */
// for(i = 0; i < data->fCount; ++i) {
while(item != NULL) {
// item = data->fData[i];
switch(item->fData->fType) {
case eStringList:
@ -188,6 +212,7 @@ rb_write(FileStream *f,
goto finish;
/*break;*/
}
item = item->fNext;
}
/* Indicate the end of the data */

84
icu4c/source/tools/makedata.mak
View file

@ -24,14 +24,16 @@ CFG=Debug
ICUDATA=$(ICUP)\icu\data
ICU_DATA=$(ICUDATA)\
DATA_PATH=$(ICUP)\icu\data^\
TRANS=translit^\
#TRANS=translit^\
TEST=..\source\test\testdata^\
TESTDATA=$(ICUP)\icu\source\test\testdata^\
ICUTOOLS=$(ICUP)\icu\source\tools
!ENDIF
LINK32 = link.exe
LINK32_FLAGS = /out:"$(ICUDATA)/icudata.dll" /DLL /NOENTRY /base:"0x4ad00000" /comment:" Copyright (C) 1999-2000 International Business Machines Corporation and others. All Rights Reserved. "
CPP_FLAGS = /I$(ICUP)\icu\include /GD /c
#CPP_FLAGS = /I$(ICUP)\icu\include /GD /c
CPP_FLAGS = /I$(ICUP)\icu\include /GD /c /Fo$@
#Here we test if configuration is given
!IF "$(CFG)" != "Release" && "$(CFG)" != "release" && "$(CFG)" != "Debug" && "$(CFG)" != "debug"
@ -92,7 +94,13 @@ GENRB_SOURCE=$(GENRB_SOURCE) $(GENRB_SOURCE_LOCAL)
!ELSE
!ERROR ERROR: cannot find "genrbfiles.mk"
!ENDIF
RB_FILES = $(GENRB_SOURCE:.txt=.res)
RB_FILES = $(GENRB_SOURCE:.txt=.res)
TRANSLIT_FILES = $(TRANSLIT_SOURCE:.txt=.res)
#TRANSLIT_SOURCE = $(TRANSLIT_SOURCE: = translit\)
!MESSAGE $(TRANSLIT_SOURCE) $(RB_FILES)
C_RB_FILES = $(RB_FILES:.res=_res.c) $(TRANSLIT_FILES:.res=_res.c)
OBJ_RB_FILES = $(C_RB_FILES:.c=.obj)
# Read list of resource bundle files for colation
!IF EXISTS("$(ICUTOOLS)\gencol\gencolfiles.mk")
@ -110,13 +118,13 @@ COL_FILES = $(GENCOL_SOURCE:.txt=.col)
# This target should build all the data files
ALL : GODATA $(RB_FILES) $(CNV_FILES) $(COL_FILES) test.dat base_test.dat test_dat.dll base_test_dat.dll base_dat.dll icudata.dat icudata.dll GOBACK
ALL : GODATA test.dat base_test.dat test_dat.dll base_test_dat.dll base_dat.dll icudata.dat $(TESTDATA)testdata.dll icudata.dll $(COL_FILES) GOBACK
@echo All targets are up to date
BRK_FILES = $(ICUDATA)\sent.brk $(ICUDATA)\char.brk $(ICUDATA)\line.brk $(ICUDATA)\word.brk $(ICUDATA)\line_th.brk $(ICUDATA)\word_th.brk
BRK_CSOURCES = $(BRK_FILES:.brk=_brk.c)
CPP_SOURCES = $(C_CNV_FILES) uprops_dat.c unames_dat.c cnvalias_dat.c tz_dat.c $(BRK_CSOURCES)
CPP_SOURCES = $(C_CNV_FILES) uprops_dat.c unames_dat.c cnvalias_dat.c tz_dat.c $(BRK_CSOURCES) $(C_RB_FILES)
LINK32_OBJS = $(CPP_SOURCES:.c=.obj)
# target for DLL
@ -158,7 +166,35 @@ icudata.dll: icudata.dat
LINK32_TEST_FLAGS = /out:"$(ICUDATA)/test_dat.dll" /DLL /NOENTRY
LINK32_BASE_TEST_FLAGS = /out:"$(ICUDATA)/base_test_dat.dll" /DLL /NOENTRY
LINK32_BASE_FLAGS = /out:"$(ICUDATA)/base_dat.dll" /DLL /NOENTRY
LINK32_TESTDATA_FLAGS = /out:"$(TESTDATA)/testdata.dll" /DLL /NOENTRY
#Targets for testdata.dll
testdata.dll : $(TESTDATA)testdata.dll
@cd $(TESTDATA)
$(TESTDATA)testdata.dll : $(TESTDATA)root_res.obj $(TESTDATA)te_res.obj $(TESTDATA)te_IN_res.obj
@echo Creating DLL file
@cd $(TESTDATA)
@$(LINK32) @<<
$(LINK32_TESTDATA_FLAGS) root_res.obj te_res.obj te_IN_res.obj
<<
$(TESTDATA)root_res.c $(TESTDATA)te_res.c $(TESTDATA)te_IN_res.c : $(TESTDATA)root.res $(TESTDATA)te.res $(TESTDATA)te_IN.res
@echo generating .c file for testdata
@cd $(TESTDATA)
@$(ICUTOOLS)\genccode\$(CFG)\genccode $?
#Targets for testdata.dat
#testdata.dat : $(TESTDATA)root.res $(TESTDATA)te.res $(TESTDATA)te_IN.res
# @echo Creating testdata.dat
# @set ICU_DATA=$(ICUDATA)
# @cd $(TESTDATA)
# @$(ICUTOOLS)\gencmn\$(CFG)\gencmn 1000000 <<
#root.res
#te.res
#te_IN.res
#<<
# Targets for test.dat
test.dat :
@echo Creating data file for test
@ -175,6 +211,7 @@ test_dat.obj : test_dat.c
$(CPP_FLAGS) $(ICUDATA)\$?
<<
#Targets for base_test.dat
base_test.dat :
@echo Creating base data file test
@ -227,7 +264,8 @@ $(ICUDATA)\word_th.brk : $(ICUDATA)\word_thLE.brk
copy $(ICUDATA)\word_thLE.brk $(ICUDATA)\word_th.brk
# target for memory mapped file
icudata.dat : $(CNV_FILES) $(BRK_FILES) uprops.dat unames.dat cnvalias.dat tz.dat
icudata.dat : $(CNV_FILES) $(BRK_FILES) uprops.dat unames.dat cnvalias.dat tz.dat $(RB_FILES) $(TRANSLIT_FILES)
@echo Creating memory-mapped file
@cd $(ICUDATA)
@$(ICUTOOLS)\gencmn\$(CFG)\gencmn -c -d $(ICUDATA) 1000000 <<
@ -235,12 +273,22 @@ $(ICUDATA)\uprops.dat
$(ICUDATA)\unames.dat
$(ICUDATA)\cnvalias.dat
$(ICUDATA)\tz.dat
$(BRK_FILES:.brk =.brk
)
$(CNV_FILES:.cnv =.cnv
)
$(RB_FILES:.res =.res
)
$(TRANSLIT_FILES:.res =.res
)
$(BRK_FILES:.brk =.brk
)
<<
# nothing works without this target, but we're making
# these files while creating converters
$(C_RB_FILES) : $(RB_FILES)
@$(ICUTOOLS)\genccode\$(CFG)\genccode $(RB_FILES)
# nothing works without this target, but we're making
# these files while creating converters
$(C_CNV_FILES) : $(CNV_FILES)
@ -286,11 +334,18 @@ CLEAN :
-@erase "*.res"
@cd $(ICUTOOLS)
{$(ICUDATA)$(TRANS)}$(TRANSLIT_FILES) : $(TRANSLIT_SOURCE)
@echo Making transliteration bundles
cd $(ICUDATA)$(TRANS)
set ICU_DATA=$(ICUDATA)
$(ICUTOOLS)\genrb\$(CFG)\genrb -s$(ICUDATA)$(TRANS) -d$(ICUDATA) $(TRANSLIT_SOURCE)
# Inference rule for creating resource bundles
.txt.res::
.txt.res:
@echo Making Resource Bundle files
@cd $(ICUDATA)
@$(ICUTOOLS)\genrb\$(CFG)\genrb $<
@echo cd $(ICUDATA)
@echo set ICU_DATA=$(ICUDATA)
$(ICUTOOLS)\genrb\$(CFG)\genrb -s$(@D) -d$(@D) $(?F)
# Inference rule for creating converters, with a kludge to create
# c versions of converters at the same time
@ -306,13 +361,14 @@ CLEAN :
.txt.col::
@echo Making Collation files
@cd $(ICUDATA)
@$(ICUTOOLS)\genrb\$(CFG)\genrb $<
@set ICU_DATA=$(ICUDATA)
$(ICUTOOLS)\gencol\$(CFG)\gencol $<
# Inference rule for compiling :)
.c.obj::
.c.obj:
@cd $(ICUDATA)
@$(CPP) @<<
$(CPP_FLAGS) $<
$(CPP_FLAGS) $?
<<
# Targets for uprops.dat