| #include <stdio.h> |
| |
| /* |
| ******************************************************************************* |
| * |
| * Copyright (C) 1999, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| * |
| ******************************************************************************* |
| * file name: udata.c |
| * encoding: US-ASCII |
| * tab size: 8 (not used) |
| * indentation:4 |
| * |
| * created on: 1999oct25 |
| * created by: Markus W. Scherer |
| */ |
| |
| #include "unicode/utypes.h" |
| #include "unicode/putil.h" |
| #include "umutex.h" |
| #include "cmemory.h" |
| #include "cstring.h" |
| #include "filestrm.h" |
| #include "unicode/udata.h" |
| |
| #if !defined(HAVE_DLOPEN) |
| # define HAVE_DLOPEN 0 |
| #endif |
| |
| #if !defined(UDATA_DLL) && !defined(UDATA_MAP) |
| # define UDATA_DLL |
| #endif |
| |
| #define COMMON_DATA_NAME "icudata" |
| #define COMMON_DATA_NAME_LENGTH 7 |
| #define DATA_TYPE "dat" |
| |
| static UDataMemory * |
| doOpenChoice(const char *path, const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode); |
| |
| U_CAPI UDataMemory * U_EXPORT2 |
| udata_open(const char *path, const char *type, const char *name, |
| UErrorCode *pErrorCode) { |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return NULL; |
| } else if(name==NULL || *name==0) { |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } else { |
| return doOpenChoice(path, type, name, NULL, NULL, pErrorCode); |
| } |
| } |
| |
| U_CAPI UDataMemory * U_EXPORT2 |
| udata_openChoice(const char *path, const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode) { |
| if(pErrorCode==NULL || U_FAILURE(*pErrorCode)) { |
| return NULL; |
| } else if(name==NULL || *name==0 || isAcceptable==NULL) { |
| *pErrorCode=U_ILLEGAL_ARGUMENT_ERROR; |
| return NULL; |
| } else { |
| return doOpenChoice(path, type, name, isAcceptable, context, pErrorCode); |
| } |
| } |
| |
| /* platform-specific implementation ----------------------------------------- */ |
| |
| /* |
| * Most implementations define a MappedData struct |
| * and have a MappedData *p; in UDataMemory. |
| * They share the source code for some functions. |
| * Other implementations need to #undef the following #define. |
| * See after the platform-specific code. |
| */ |
| #define UDATA_INDIRECT |
| |
| static bool_t |
| isCommonDataAcceptable(void *context, |
| const char *type, const char *name, |
| UDataInfo *pInfo); |
| |
| #if defined(WIN32) /* Win32 implementations --------------------------------- */ |
| |
| #include <windows.h> |
| |
| typedef struct { |
| uint16_t headerSize; |
| uint8_t magic1, magic2; |
| } MappedData; |
| |
| # if defined(UDATA_DLL) /* Win32 dll implementation ----------------------- */ |
| |
| struct UDataMemory { |
| HINSTANCE lib; |
| MappedData *p; |
| }; |
| |
| typedef HINSTANCE Library; |
| |
| static MappedData * |
| getChoice(Library lib, const char *entry, |
| const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode); |
| |
| #define LIB_SUFFIX ".dll" |
| |
| /* skip the bogus double */ |
| #define GET_ENTRY(lib, entryName) getWIN32Entry(lib, entryName) /*(MappedData *)(((double*)GetProcAddress(lib, entryName))+1)*/ |
| |
| static MappedData *getWIN32Entry(Library lib, const char *entryName) { |
| MappedData *m; |
| m = (MappedData *)GetProcAddress(lib, entryName); |
| return (MappedData *)(m==NULL?NULL:((double*)m)+1); |
| } |
| |
| #define NO_LIBRARY NULL |
| #define IS_LIBRARY(lib) ((lib)!=NULL) |
| #define LOAD_LIBRARY(path, basename, isCommon) LoadLibrary(path); |
| #define UNLOAD_LIBRARY(lib) FreeLibrary(lib) |
| |
| # else /* Win32 memory map implementation --------------------------------- */ |
| |
| struct UDataMemory { |
| HANDLE map; |
| MappedData *p; |
| }; |
| |
| typedef UDataMemory *Library; |
| |
| UDataMemory *udata_createCommonData( MappedData* data) |
| { |
| static UDataMemory myMemory; |
| |
| myMemory.p = data; |
| |
| return &myMemory; |
| } |
| |
| |
| static MappedData * |
| getChoice(Library lib, const char *entry, |
| const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode); |
| |
| #define LIB_SUFFIX ".dat" |
| |
| #define GET_ENTRY(lib, entryName) getCommonMapData(lib, entryName) |
| |
| #define NO_LIBRARY NULL |
| #define IS_LIBRARY(lib) ((lib)!=NULL) |
| #define UNLOAD_LIBRARY(lib) udata_close((UDataMemory *)(lib)) |
| |
| static Library |
| LOAD_LIBRARY(const char *path, const char *basename, bool_t isCommon) { |
| char buffer[40]; |
| UDataMemory *pData; |
| MappedData *p; |
| HANDLE map; |
| UErrorCode errorCode=U_ZERO_ERROR; |
| |
| /* set up the mapping name and the filename */ |
| uprv_strcpy(buffer, "icu "); |
| uprv_strcat(buffer, basename); |
| |
| /* open the mapping */ |
| map=OpenFileMapping(FILE_MAP_READ, FALSE, buffer); |
| if(map==NULL) { |
| /* the mapping has not been created */ |
| HANDLE file; |
| |
| /* open the input file */ |
| file=CreateFile(path, GENERIC_READ, FILE_SHARE_READ, NULL, |
| OPEN_EXISTING, |
| FILE_ATTRIBUTE_NORMAL|FILE_FLAG_RANDOM_ACCESS, NULL); |
| if(file==INVALID_HANDLE_VALUE) { |
| return NULL; |
| } |
| |
| /* create the mapping */ |
| map=CreateFileMapping(file, NULL, PAGE_READONLY, 0, 0, buffer); |
| CloseHandle(file); |
| if(map==NULL) { |
| return NULL; |
| } |
| } |
| |
| /* get a view of the mapping */ |
| p=(MappedData *)MapViewOfFile(map, FILE_MAP_READ, 0, 0, 0); |
| if(p==NULL) { |
| CloseHandle(map); |
| return NULL; |
| } |
| |
| /* allocate the data structure */ |
| pData=(UDataMemory *)uprv_malloc(sizeof(UDataMemory)); |
| if(pData==NULL) { |
| UnmapViewOfFile(pData->p); |
| CloseHandle(map); |
| return NULL; |
| } |
| |
| pData->map=map; |
| pData->p=p; |
| |
| /* is it acceptable? */ |
| if(NULL==getChoice(pData, NULL, DATA_TYPE, COMMON_DATA_NAME, |
| isCommon ? isCommonDataAcceptable : NULL, NULL, &errorCode) |
| ) { |
| udata_close(pData); |
| return NULL; |
| } |
| |
| return (Library)pData; |
| } |
| |
| U_CAPI void U_EXPORT2 |
| udata_close(UDataMemory *pData) { |
| if(pData!=NULL) { |
| if(pData->map!=NULL) { |
| UnmapViewOfFile(pData->p); |
| CloseHandle(pData->map); |
| } |
| uprv_free(pData); |
| } |
| } |
| |
| # endif |
| |
| /* POSIX implementations ---------------------------------------------------- */ |
| |
| #elif defined (LINUX)||defined(POSIX)||defined(SOLARIS)||defined(AIX)||defined(HPUX) |
| |
| /* If you are excruciatingly bored turn this on .. */ |
| /* #define UDATA_DEBUG 1 */ |
| |
| typedef struct { |
| uint16_t headerSize; |
| uint8_t magic1, magic2; |
| } MappedData; |
| |
| #if defined(UDATA_DEBUG) |
| #include <stdio.h> |
| #endif |
| |
| /* add more to this list as more platform's dll support is written */ |
| # if defined(UDATA_DLL) && (HAVE_DLOPEN) |
| |
| struct UDataMemory { |
| void *lib; |
| MappedData *p; |
| }; |
| |
| #ifndef UDATA_SO_SUFFIX |
| # error Please define UDATA_SO_SUFFIX to the shlib suffix (i.e. '.so' ) |
| #endif |
| |
| #define LIB_PREFIX "lib" |
| #define LIB_PREFIX_LENGTH 3 |
| #define LIB_SUFFIX UDATA_SO_SUFFIX |
| |
| /* Do we need to check the platform here? */ |
| |
| #if defined(ICU_USE_SHL_LOAD) |
| |
| |
| # include <dl.h> |
| /* HPUX compatibility stubs: shl_load, etc.. */ |
| #define RTLD_LAZY 0 |
| #define RTLD_GLOBAL 0 |
| |
| void *dlopen (const char *filename, int flag) |
| { |
| void *handle; /* real type: 'shl_t' */ |
| |
| #ifdef UDATA_DEBUG |
| fprintf(stderr, "shl_load: %s ", filename); |
| #endif |
| |
| handle = shl_load(filename, BIND_NONFATAL | BIND_DEFERRED | DYNAMIC_PATH , 0L); |
| |
| #ifdef UDATA_DEBUG |
| fprintf(stderr, " -> %08X\n", handle ); |
| #endif |
| |
| return handle; |
| } |
| |
| |
| |
| void *dlsym(void *h, char *symbol) |
| { |
| void *val = 0; |
| int rv; |
| shl_t mysh; |
| |
| mysh = (shl_t)h; /* real type */ |
| |
| rv = shl_findsym(&mysh,symbol,TYPE_DATA,(void*)&val); |
| |
| #ifdef UDATA_DEBUG |
| fprintf(stderr, "shl_findsym(%08X, %s) -> %08X [%d]\n", h, |
| symbol, val, rv); |
| #endif |
| |
| |
| return val; |
| |
| } |
| |
| int dlclose (void *handle) |
| { |
| #ifdef UDATA_DEBUG |
| fprintf(stderr, "shl_unload: %08X\n", handle); |
| #endif |
| |
| return shl_unload((shl_t)handle); |
| } |
| |
| |
| |
| #else |
| /* 'de facto standard' dlopen etc */ |
| # include <dlfcn.h> |
| #endif |
| |
| |
| typedef void *Library; |
| |
| static MappedData * |
| getChoice(Library lib, const char *entry, |
| const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode); |
| |
| #define GET_ENTRY(lib, entryName) getPOSIXEntry(lib, entryName) /*(MappedData *)(((double*)dlsym(lib, entryName))+1)*/ |
| |
| static MappedData *getPOSIXEntry(Library lib, const char *entryName) { |
| MappedData *m; |
| m = dlsym(lib, entryName); |
| return (MappedData *)(m==NULL?NULL:((double *)m)+1); |
| } |
| |
| |
| #define NO_LIBRARY NULL |
| #define IS_LIBRARY(lib) ((lib)!=NULL) |
| #define LOAD_LIBRARY(path, basename, isCommon) dlopen(path, RTLD_LAZY|RTLD_GLOBAL); |
| #define UNLOAD_LIBRARY(lib) dlclose(lib) |
| |
| # else /* POSIX memory map implementation --------------------------------- */ |
| #ifdef UDATA_DLL |
| #undef UDATA_DLL |
| #endif |
| |
| #ifndef UDATA_MAP |
| #define UDATA_MAP |
| #endif |
| |
| #include <unistd.h> |
| #include <sys/mman.h> |
| #include <sys/stat.h> |
| #include <fcntl.h> |
| |
| #ifndef MAP_FAILED |
| #define MAP_FAILED ((void*)-1) |
| #endif |
| |
| struct UDataMemory { |
| size_t length; |
| MappedData *p; |
| }; |
| |
| typedef UDataMemory *Library; |
| |
| /* Set a static data memory and use it */ |
| UDataMemory *udata_createCommonData( MappedData* data) |
| { |
| static UDataMemory myMemory; |
| myMemory.p = data; |
| return &myMemory; |
| } |
| |
| |
| static MappedData * |
| getChoice(Library lib, const char *entry, |
| const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode); |
| |
| #define LIB_SUFFIX ".dat" |
| |
| #define GET_ENTRY(lib, entryName) getCommonMapData(lib, entryName) |
| |
| #define NO_LIBRARY NULL |
| #define IS_LIBRARY(lib) ((lib)!=NULL) |
| #define UNLOAD_LIBRARY(lib) udata_close((UDataMemory *)(lib)) |
| |
| static Library |
| LOAD_LIBRARY(const char *path, const char *basename, bool_t isCommon) { |
| UDataMemory *pData; |
| UDataInfo *info; |
| int fd; |
| int length; |
| const char *dataDir; |
| struct stat mystat; |
| void *data; |
| UErrorCode errorCode = U_ZERO_ERROR; |
| |
| /* determine the length of the file */ |
| if(stat(path, &mystat)) |
| { |
| return NULL; |
| } |
| |
| length = mystat.st_size; |
| |
| fd = open(path, O_RDONLY); |
| |
| if(fd == -1) |
| { |
| return NULL; |
| } |
| |
| /* get a view of the mapping */ |
| data = mmap(0, length, PROT_READ, MAP_SHARED, fd, 0); |
| |
| close(fd); /* no longer needed */ |
| |
| if(data == MAP_FAILED) |
| { |
| perror("mmap"); |
| return NULL; |
| } |
| |
| #ifdef UDATA_DEBUG |
| fprintf(stderr, "mmap of %s [%d bytes] succeeded, -> 0x%X\n", |
| path, length, data); |
| fflush(stderr); |
| #endif |
| |
| /* allocate the data structure */ |
| pData=(UDataMemory *)uprv_malloc(sizeof(UDataMemory)); |
| if(pData==NULL) { |
| munmap(data, length); |
| return NULL; |
| } |
| |
| pData->length = length; |
| pData->p =(MappedData *)data; |
| |
| /* is it acceptable? */ |
| if(NULL==getChoice(pData, NULL, DATA_TYPE, COMMON_DATA_NAME, |
| isCommon ? isCommonDataAcceptable : NULL, NULL, &errorCode) |
| ) { |
| udata_close(pData); |
| return NULL; |
| } |
| |
| return pData; |
| } |
| |
| U_CAPI void U_EXPORT2 |
| udata_close(UDataMemory *pData) { |
| if(pData!=NULL) { |
| if(pData->length!=0 && munmap(pData->p, pData->length)==-1) { |
| perror("munmap"); |
| } |
| uprv_free(pData); |
| } |
| } |
| # endif |
| |
| #else /* unknown platform - stdio fopen()/fread() implementation ------------ */ |
| |
| #include <stdio.h> |
| |
| #undef UDATA_INDIRECT |
| #undef UDATA_DLL |
| #ifndef UDATA_MAP |
| # define UDATA_MAP |
| #endif |
| |
| struct UDataMemory { |
| uint16_t headerSize; |
| uint8_t magic1, magic2; |
| }; |
| |
| typedef UDataMemory MappedData; |
| typedef UDataMemory *Library; |
| |
| static MappedData * |
| getChoice(Library lib, const char *entry, |
| const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode); |
| |
| #define GET_ENTRY(lib, entryName) (lib) |
| |
| #define NO_LIBRARY NULL |
| #define IS_LIBRARY(lib) ((lib)!=NULL) |
| #define UNLOAD_LIBRARY(lib) uprv_free(lib) |
| |
| static Library |
| LOAD_LIBRARY(const char *path, const char *basename, bool_t isCommon) { |
| FileStream *file; |
| UDataMemory *pData; |
| int32_t fileLength; |
| |
| /* open the input file */ |
| file=T_FileStream_open(path, "rb"); |
| if(file==NULL) { |
| return NULL; |
| } |
| |
| /* get the file length */ |
| fileLength=T_FileStream_size(file); |
| if(T_FileStream_error(file) || fileLength<=20) { |
| T_FileStream_close(file); |
| return NULL; |
| } |
| |
| /* allocate the data structure */ |
| pData=(UDataMemory *)uprv_malloc(fileLength); |
| if(pData==NULL) { |
| T_FileStream_close(file); |
| return NULL; |
| } |
| |
| /* read the file */ |
| if(fileLength!=T_FileStream_read(file, pData, fileLength)) { |
| uprv_free(pData); |
| T_FileStream_close(file); |
| return NULL; |
| } |
| |
| T_FileStream_close(file); |
| |
| return pData; |
| } |
| |
| U_CAPI void U_EXPORT2 |
| udata_close(UDataMemory *pData) { |
| if(pData!=NULL) { |
| uprv_free(pData); |
| } |
| } |
| |
| U_CAPI const void * U_EXPORT2 |
| udata_getMemory(UDataMemory *pData) { |
| if(pData!=NULL) { |
| return (char *)pData+pData->headerSize; |
| } else { |
| return NULL; |
| } |
| } |
| |
| U_CAPI void U_EXPORT2 |
| udata_getInfo(UDataMemory *pData, UDataInfo *pInfo) { |
| if(pInfo!=NULL) { |
| if(pData!=NULL) { |
| UDataInfo *info=(UDataInfo *)(pData+1); |
| uint16_t size=pInfo->size; |
| if(size>info->size) { |
| pInfo->size=info->size; |
| } |
| uprv_memcpy((uint16_t *)pInfo+1, (uint16_t *)info+1, size-2); |
| } else { |
| pInfo->size=0; |
| } |
| } |
| } |
| #endif |
| |
| /* common function implementations ------------------------------------------ */ |
| |
| #ifdef UDATA_INDIRECT |
| |
| # ifdef UDATA_DLL |
| |
| /* common DLL implementations */ |
| |
| U_CAPI void U_EXPORT2 |
| udata_close(UDataMemory *pData) { |
| if(pData!=NULL) { |
| if(IS_LIBRARY(pData->lib)) { |
| UNLOAD_LIBRARY(pData->lib); |
| } |
| uprv_free(pData); |
| } |
| } |
| |
| # else |
| |
| /* common implementation of use of common memory map */ |
| |
| /* this is the memory-map version of GET_ENTRY(), used by getChoice() */ |
| static MappedData * |
| getCommonMapData(const UDataMemory *data, const char *dataName) { |
| /* dataName==NULL if no lookup in a table of contents is necessary */ |
| if(dataName!=NULL) { |
| const char *base=(const char *)(data->p)+data->p->headerSize; |
| uint32_t *toc=(uint32_t *)base; |
| uint32_t start, limit, number; |
| |
| /* perform a binary search for the data in the common data's table of contents */ |
| start=0; |
| limit=*toc++; /* number of names in this table of contents */ |
| while(start<limit-1) { |
| number=(start+limit)/2; |
| if(uprv_strcmp(dataName, (const char *)(base+toc[2*number]))<0) { |
| limit=number; |
| } else { |
| start=number; |
| } |
| } |
| |
| if(uprv_strcmp(dataName, (const char *)(base+toc[2*start]))==0) { |
| /* found it */ |
| return (MappedData *)(base+toc[2*start+1]); |
| } else { |
| return NULL; |
| } |
| } else { |
| return data->p; |
| } |
| } |
| |
| static bool_t |
| isCommonDataAcceptable(void *context, |
| const char *type, const char *name, |
| UDataInfo *pInfo) { |
| return |
| pInfo->size>=20 && |
| pInfo->isBigEndian==U_IS_BIG_ENDIAN && |
| pInfo->charsetFamily==U_CHARSET_FAMILY && |
| pInfo->sizeofUChar==sizeof(UChar) && |
| pInfo->dataFormat[0]==0x43 && /* dataFormat="CmnD" */ |
| pInfo->dataFormat[1]==0x6d && |
| pInfo->dataFormat[2]==0x6e && |
| pInfo->dataFormat[3]==0x44 && |
| pInfo->formatVersion[0]==1; |
| } |
| |
| # endif |
| |
| /* common implementations of other functions for indirect mappings */ |
| |
| U_CAPI const void * U_EXPORT2 |
| udata_getMemory(UDataMemory *pData) { |
| if(pData!=NULL) { |
| return (char *)(pData->p)+pData->p->headerSize; |
| } else { |
| return NULL; |
| } |
| } |
| |
| U_CAPI void U_EXPORT2 |
| udata_getInfo(UDataMemory *pData, UDataInfo *pInfo) { |
| if(pInfo!=NULL) { |
| if(pData!=NULL) { |
| UDataInfo *info=(UDataInfo *)(pData->p+1); |
| uint16_t size=pInfo->size; |
| if(size>info->size) { |
| pInfo->size=info->size; |
| } |
| uprv_memcpy((uint16_t *)pInfo+1, (uint16_t *)info+1, size-2); |
| } else { |
| pInfo->size=0; |
| } |
| } |
| } |
| |
| #endif |
| |
| /* function implementations for all platforms ------------------------------- */ |
| |
| static Library commonLib=NO_LIBRARY; |
| |
| |
| void |
| udata_setCommonData(const void *data, UErrorCode *err) |
| { |
| #ifndef UDATA_MAP |
| *err = U_UNSUPPORTED_ERROR; |
| return; |
| |
| #else |
| MappedData *p; |
| |
| if(U_FAILURE(*err)) |
| { |
| return; |
| } |
| |
| if(IS_LIBRARY(commonLib)) /* ... already got one */ |
| { |
| *err = U_USING_DEFAULT_ERROR; |
| return; |
| } |
| |
| if(data == NULL) |
| { |
| *err = U_ILLEGAL_ARGUMENT_ERROR; |
| return; |
| } |
| |
| /* try it direct */ |
| p = (MappedData*)data; |
| if(p->magic1!=0xda || p->magic2!=0x27) |
| { |
| /* Didn't work, offset it */ |
| p = (MappedData*) (((double *)data)+1); |
| |
| if(p->magic1!=0xda || p->magic2!=0x27) |
| { |
| *err = U_INVALID_FORMAT_ERROR; /* Didn't find the magic. */ |
| return; |
| } |
| } |
| |
| commonLib = udata_createCommonData(p); |
| |
| #endif |
| } |
| |
| |
| static const char *strcpy_dllentry(char *target, const char *src) |
| { |
| int i, length; |
| |
| uprv_strcpy(target,src); |
| length = uprv_strlen(target); |
| for(i=0;i<length;i++) |
| { |
| if(target[i] == '-') |
| { |
| target[i] = '_'; |
| } |
| } |
| return target; |
| } |
| |
| static const char *strcat_dllentry(char *target, const char *src) |
| { |
| int i, length; |
| |
| i = uprv_strlen(target); /* original size */ |
| |
| uprv_strcat(target,src); |
| |
| length = i + uprv_strlen(src); |
| |
| for(;i<length;i++) |
| { |
| if(target[i] == '-') |
| { |
| target[i] = '_'; |
| } |
| } |
| return target; |
| } |
| |
| static UDataMemory * |
| doOpenChoice(const char *path, const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode) { |
| char pathBuffer[512]; |
| char entryNameBuffer[40]; |
| char *basename, *suffix; |
| const char *entryName; |
| bool_t isICUData, hasPath, hasBasename; |
| |
| Library lib; |
| MappedData *p; |
| UErrorCode errorCode=U_ZERO_ERROR; |
| |
| #ifdef OS390BATCH |
| /* Try DD:ICUDATA first */ |
| char *c; |
| char tmpPathName[23]; |
| #endif |
| /* set up path and basename */ |
| if(path==NULL) { |
| isICUData=TRUE; |
| basename=pathBuffer; |
| |
| /* copy the path to the path buffer */ |
| path=u_getDataDirectory(); |
| if(path!=NULL && *path!=0) { |
| int length=uprv_strlen(path); |
| uprv_memcpy(pathBuffer, path, length); |
| basename+=length; |
| hasPath=TRUE; |
| } else { |
| hasPath=FALSE; |
| } |
| |
| /* add (prefix and) basename */ |
| # ifndef LIB_PREFIX |
| uprv_strcpy(basename, COMMON_DATA_NAME); |
| suffix=basename+COMMON_DATA_NAME_LENGTH; |
| # else |
| uprv_memcpy(basename, LIB_PREFIX, LIB_PREFIX_LENGTH); |
| uprv_strcpy(basename+LIB_PREFIX_LENGTH, COMMON_DATA_NAME); |
| suffix=basename+LIB_PREFIX_LENGTH+COMMON_DATA_NAME_LENGTH; |
| # endif |
| hasBasename=TRUE; |
| } else { |
| char *basename2; |
| |
| isICUData=FALSE; |
| |
| /* find the last file sepator */ |
| basename=uprv_strrchr(path, '/'); |
| if(basename==NULL) { |
| basename=(char *)path; |
| } else { |
| ++basename; |
| } |
| |
| basename2=uprv_strrchr(basename, '\\'); |
| if(basename2!=NULL) { |
| basename=basename2+1; |
| } |
| |
| if(path!=basename) { |
| # ifndef LIB_PREFIX |
| /* copy the path/basename to the path buffer */ |
| uprv_strcpy(pathBuffer, path); |
| basename=pathBuffer+(basename-path); |
| # else |
| /* copy the path to the path buffer */ |
| uprv_memcpy(pathBuffer, path, basename-path); |
| |
| /* add prefix and basename */ |
| suffix=pathBuffer+(basename-path); |
| uprv_memcpy(suffix, LIB_PREFIX, LIB_PREFIX_LENGTH); |
| uprv_strcpy(suffix+LIB_PREFIX_LENGTH, basename); |
| basename=suffix; |
| # endif |
| hasPath=TRUE; |
| } else { |
| /* copy the path to the path buffer */ |
| path=u_getDataDirectory(); |
| if(path!=NULL && *path!=0) { |
| int length=uprv_strlen(path); |
| uprv_memcpy(pathBuffer, path, length); |
| suffix=pathBuffer+length; |
| hasPath=TRUE; |
| } else { |
| suffix=pathBuffer; |
| hasPath=FALSE; |
| } |
| |
| /* add (prefix and) basename */ |
| # ifndef LIB_PREFIX |
| uprv_strcpy(suffix, basename); |
| # else |
| uprv_memcpy(suffix, LIB_PREFIX, LIB_PREFIX_LENGTH); |
| uprv_strcpy(suffix+LIB_PREFIX_LENGTH, basename); |
| # endif |
| basename=suffix; |
| } |
| hasBasename= *basename!=0; |
| if(hasBasename) { |
| suffix=basename+uprv_strlen(basename); |
| } |
| } |
| path=pathBuffer; |
| |
| /* set up the entry point name */ |
| if(type!=NULL && *type!=0) { |
| #ifdef UDATA_DLL |
| strcpy_dllentry(entryNameBuffer, name); |
| #else |
| uprv_strcpy(entryNameBuffer, name); |
| #endif |
| |
| # ifdef UDATA_DLL |
| uprv_strcat(entryNameBuffer, "_"); |
| # else |
| uprv_strcat(entryNameBuffer, "."); |
| # endif |
| |
| #ifdef UDATA_DLL |
| strcat_dllentry(entryNameBuffer, type); |
| #else |
| uprv_strcat(entryNameBuffer, type); |
| #endif |
| |
| entryName=entryNameBuffer; |
| } else { |
| #ifdef UDATA_DLL |
| strcpy_dllentry(entryNameBuffer, name); |
| entryName=entryNameBuffer; |
| #else |
| entryName=name; |
| #endif |
| } |
| |
| /* try the common data first */ |
| p=NULL; |
| |
| #ifdef OS390BATCH |
| /* |
| Try DD:ICUDATA first. |
| */ |
| uprv_strcpy(tmpPathName, "//DD:ICUDATA("); |
| /* |
| Delete the '-' character from the file name. It is not a vaild |
| charater for a MVS data set name. |
| We could convert it to '@', but because icu supports 9 character |
| converter file name(for example, ibm-12712.cnv), it's better to |
| delete it(member name of a PDS must be <= 8 characters). |
| */ |
| c = uprv_strstr(name, "-"); |
| if (c != NULL) { |
| uprv_strncat(tmpPathName, name, c-name); |
| uprv_strcat(tmpPathName, c+1); |
| } |
| else |
| uprv_strcat(tmpPathName, name); |
| uprv_strcat(tmpPathName, ")"); |
| lib=LOAD_LIBRARY(tmpPathName, name, FALSE); |
| |
| if(IS_LIBRARY(lib)) { |
| /* look for the entry point */ |
| # ifdef UDATA_MAP |
| /* entryName passed as NULL: prevent TOC lookup for single, mapped files */ |
| p=getChoice(lib, NULL, type, name, isAcceptable, context, &errorCode); |
| # else |
| p=getChoice(lib, entryName, type, name, isAcceptable, context, &errorCode); |
| # endif |
| if(p==NULL) |
| UNLOAD_LIBRARY(lib); |
| } |
| |
| if(p==NULL) { |
| |
| #endif |
| # ifdef UDATA_INDIRECT |
| if(hasBasename) { |
| /* get the common data */ |
| /* do we have it cached? */ |
| if(isICUData) { |
| lib=commonLib; |
| } else { |
| lib=NO_LIBRARY; |
| } |
| |
| /* load the common data if neccessary */ |
| if(!IS_LIBRARY(lib)) { |
| /* try path/basename first */ |
| uprv_strcpy(suffix, LIB_SUFFIX); |
| lib=LOAD_LIBRARY(path, basename, TRUE); |
| if(!IS_LIBRARY(lib)) { |
| /* try basename only next */ |
| lib=LOAD_LIBRARY(basename, basename, TRUE); |
| } |
| |
| /* set the cache if appropriate */ |
| if(isICUData && IS_LIBRARY(lib)) { |
| bool_t setThisLib=FALSE; |
| |
| /* in the mutex block, set the common library for this process */ |
| umtx_lock(NULL); |
| if(!IS_LIBRARY(commonLib)) { |
| commonLib=lib; |
| setThisLib=TRUE; |
| } |
| umtx_unlock(NULL); |
| |
| /* if a different thread set it first, then free the extra library instance */ |
| if(!setThisLib) { |
| UNLOAD_LIBRARY(lib); |
| lib=commonLib; |
| } |
| } |
| } |
| |
| if(IS_LIBRARY(lib)) { |
| /* look for the entry point in this common data */ |
| p=getChoice(lib, entryName, type, name, isAcceptable, context, &errorCode); |
| if(p!=NULL) { |
| if(isICUData) { |
| lib=NO_LIBRARY; |
| } |
| } else { |
| if(!isICUData) { |
| UNLOAD_LIBRARY(lib); |
| } |
| } |
| } |
| } |
| # endif |
| |
| #ifdef OS390BATCH |
| } |
| #endif |
| /* if the data is not found in the common data, then look for a separate library */ |
| |
| /* try basename+"_"+entryName[+LIB_SUFFIX] first */ |
| if(p==NULL && hasBasename) { |
| *suffix='_'; |
| uprv_strcpy(suffix+1, entryName); |
| # ifdef UDATA_DLL |
| uprv_strcat(suffix+1, LIB_SUFFIX); |
| # endif |
| |
| /* try path/basename first */ |
| lib=LOAD_LIBRARY(path, basename, FALSE); |
| if(!IS_LIBRARY(lib)) { |
| /* try basename only next */ |
| lib=LOAD_LIBRARY(basename, basename, FALSE); |
| } |
| |
| if(IS_LIBRARY(lib)) { |
| /* look for the entry point */ |
| # ifdef UDATA_MAP |
| /* entryName passed as NULL: prevent TOC lookup for single, mapped files */ |
| p=getChoice(lib, NULL, type, name, isAcceptable, context, &errorCode); |
| # else |
| p=getChoice(lib, entryName, type, name, isAcceptable, context, &errorCode); |
| # endif |
| if(p==NULL) { |
| UNLOAD_LIBRARY(lib); |
| } |
| } |
| } |
| |
| /* try entryName[+LIB_SUFFIX] next */ |
| if(p==NULL) { |
| # ifndef LIB_PREFIX |
| uprv_strcpy(basename, entryName); |
| # else |
| uprv_strcpy(basename+LIB_PREFIX_LENGTH, entryName); |
| # endif |
| # ifdef UDATA_DLL |
| uprv_strcat(basename, LIB_SUFFIX); |
| # endif |
| |
| /* try path/basename first */ |
| lib=LOAD_LIBRARY(path, basename, FALSE); |
| if(!IS_LIBRARY(lib)) { |
| /* try basename only next */ |
| lib=LOAD_LIBRARY(basename, basename, FALSE); |
| } |
| |
| if(IS_LIBRARY(lib)) { |
| /* look for the entry point */ |
| # ifdef UDATA_MAP |
| /* entryName passed as NULL: prevent TOC lookup for single, mapped files */ |
| p=getChoice(lib, NULL, type, name, isAcceptable, context, &errorCode); |
| # else |
| p=getChoice(lib, entryName, type, name, isAcceptable, context, &errorCode); |
| # endif |
| if(p==NULL) { |
| UNLOAD_LIBRARY(lib); |
| } |
| } |
| } |
| |
| /* return the data if found */ |
| if(p!=NULL) { |
| # ifndef UDATA_INDIRECT |
| /* for direct mappings, Library==UDataMemory==MappedData */ |
| return (UDataMemory *)lib; |
| # else |
| UDataMemory *pData; |
| |
| # ifdef UDATA_MAP |
| if(IS_LIBRARY(lib)) { |
| /* for mapped files, Library==UDataMemory */ |
| pData=(UDataMemory *)lib; |
| pData->p=p; |
| return pData; |
| } |
| # endif |
| |
| /* allocate the data structure */ |
| pData=(UDataMemory *)uprv_malloc(sizeof(UDataMemory)); |
| if(pData==NULL) { |
| if(IS_LIBRARY(lib)) { |
| UNLOAD_LIBRARY(lib); |
| } |
| *pErrorCode=U_MEMORY_ALLOCATION_ERROR; |
| return NULL; |
| } |
| |
| # ifdef UDATA_DLL |
| pData->lib=lib; |
| # else |
| /* defined(UDATA_MAP) && !IS_LIBRARY(lib) */ |
| uprv_memset(pData, 0, sizeof(pData)); |
| # endif |
| |
| pData->p=p; |
| return pData; |
| # endif |
| } |
| |
| /* data not found */ |
| if(U_SUCCESS(*pErrorCode)) { |
| if(U_SUCCESS(errorCode)) { |
| /* file not found */ |
| *pErrorCode=U_FILE_ACCESS_ERROR; |
| } else { |
| /* entry point not found or rejected */ |
| *pErrorCode=errorCode; |
| } |
| } |
| return NULL; |
| } |
| |
| static MappedData * |
| getChoice(Library lib, const char *entry, |
| const char *type, const char *name, |
| UDataMemoryIsAcceptable *isAcceptable, void *context, |
| UErrorCode *pErrorCode) { |
| MappedData *p; |
| UDataInfo *info; |
| |
| /* get the data pointer */ |
| p=GET_ENTRY(lib, entry); |
| if(p==NULL) { |
| *pErrorCode=U_FILE_ACCESS_ERROR; |
| return NULL; |
| } |
| info=(UDataInfo *)(p+1); |
| |
| /* check magic1 & magic2 */ |
| /* check for the byte ordering */ |
| /* is this acceptable? */ |
| if( p->magic1!=0xda || p->magic2!=0x27 || |
| info->isBigEndian!=U_IS_BIG_ENDIAN || |
| isAcceptable!=NULL && !isAcceptable(context, type, name, info) |
| ) { |
| *pErrorCode=U_INVALID_FORMAT_ERROR; |
| return NULL; |
| } |
| |
| return p; |
| } |
