AuroraMiddleware/scuffed-code
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
4414ab71fa
scuffed-code/icu4c/source/common/udata.c

962 lines
25 KiB
C
Raw Normal View History

ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
/*
*******************************************************************************
* *
* COPYRIGHT: *
* (C) Copyright International Business Machines Corporation, 1999 *
* Licensed Material - Program-Property of IBM - All Rights Reserved. *
* US Government Users Restricted Rights - Use, duplication, or disclosure *
* restricted by GSA ADP Schedule Contract with IBM Corp. *
* *
*******************************************************************************
* file name: udata.c
* encoding: US-ASCII
* tab size: 8 (not used)
* indentation:4
*
* created on: 1999oct25
* created by: Markus W. Scherer
*/
#include "utypes.h"
#include "putil.h"
#include "umutex.h"
#include "cmemory.h"
#include "cstring.h"
#include "filestrm.h"
#include "udata.h"
ICU-157 converter data in udata + udata fixes X-SVN-Rev: 296
1999-12-04 02:31:40 +00:00
#if !defined(HAVE_DLOPEN)
# define HAVE_DLOPEN 0
#endif
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
#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"
ICU-157 UDATA updates for Machines with Alignment Problems, and to align cnv/ucmp data. X-SVN-Rev: 416
1999-12-15 05:14:03 +00:00
/* skip the bogus double */
#define GET_ENTRY(lib, entryName) (MappedData *)(((double*)GetProcAddress(lib, entryName))+1)
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
#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;
static MappedData *
getChoice(Library lib, const char *entry,
const char *type, const char *name,
UDataMemoryIsAcceptable *isAcceptable, void *context,
UErrorCode *pErrorCode);
#define LIB_SUFFIX ".dat"
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
#define GET_ENTRY(lib, entryName) getCommonMapData(lib, entryName)
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
#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 */
icu_strcpy(buffer, "icu ");
icu_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 *)icu_malloc(sizeof(UDataMemory));
if(pData==NULL) {
UnmapViewOfFile(pData->p);
CloseHandle(map);
return NULL;
}
pData->map=map;
pData->p=p;
/* is it acceptable? */
ICU-157 fixed opening single, mapped files X-SVN-Rev: 338
1999-12-08 01:11:01 +00:00
if(NULL==getChoice(pData, NULL, DATA_TYPE, COMMON_DATA_NAME,
isCommon ? isCommonDataAcceptable : NULL, NULL, &errorCode)
) {
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
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);
}
icu_free(pData);
}
}
# endif
/* POSIX implementations ---------------------------------------------------- */
#elif defined (LINUX)||defined(POSIX)||defined(SOLARIS)||defined(AIX)||defined(HPUX)
ICU-157 fix mapped data on some platforms X-SVN-Rev: 391
1999-12-13 21:36:13 +00:00
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
typedef struct {
uint16_t headerSize;
uint8_t magic1, magic2;
} MappedData;
#if defined(UDATA_DEBUG)
#include <stdio.h>
#endif
ICU-157 posix support for udata.. linux dll support.. posix should work with mmapped files OK X-SVN-Rev: 235
1999-11-23 04:49:35 +00:00
/* add more to this list as more platform's dll support is written */
ICU-157 converter data in udata + udata fixes X-SVN-Rev: 296
1999-12-04 02:31:40 +00:00
# if defined(UDATA_DLL) && (HAVE_DLOPEN)
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
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? */
#include <dlfcn.h>
ICU-157 fix mapped data on some platforms X-SVN-Rev: 391
1999-12-13 21:36:13 +00:00
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
typedef void *Library;
static MappedData *
getChoice(Library lib, const char *entry,
const char *type, const char *name,
UDataMemoryIsAcceptable *isAcceptable, void *context,
UErrorCode *pErrorCode);
ICU-157 UDATA updates for Machines with Alignment Problems, and to align cnv/ucmp data. X-SVN-Rev: 416
1999-12-15 05:14:03 +00:00
#define GET_ENTRY(lib, entryName) (MappedData *)(((double*)dlsym(lib, entryName))+1)
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
#define NO_LIBRARY NULL
#define IS_LIBRARY(lib) ((lib)!=NULL)
ICU-157 converter data in udata + udata fixes X-SVN-Rev: 296
1999-12-04 02:31:40 +00:00
#define LOAD_LIBRARY(path, basename, isCommon) dlopen(path, RTLD_LAZY|RTLD_GLOBAL);
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
#define UNLOAD_LIBRARY(lib) dlclose(lib)
# else /* POSIX memory map implementation --------------------------------- */
ICU-157 converter data in udata + udata fixes X-SVN-Rev: 296
1999-12-04 02:31:40 +00:00
#ifdef UDATA_DLL
#undef UDATA_DLL
#endif
#ifndef UDATA_MAP
#define UDATA_MAP
#endif
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
#include <unistd.h>
#include <sys/mman.h>
#include <sys/stat.h>
ICU-157 udata mapped support for AIX X-SVN-Rev: 398
1999-12-14 01:07:43 +00:00
#include <fcntl.h>
#ifndef MAP_FAILED
#define MAP_FAILED ((void*)-1)
#endif
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
struct UDataMemory {
size_t length;
MappedData *p;
};
typedef UDataMemory *Library;
static MappedData *
getChoice(Library lib, const char *entry,
const char *type, const char *name,
UDataMemoryIsAcceptable *isAcceptable, void *context,
UErrorCode *pErrorCode);
#define LIB_SUFFIX ".dat"
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
#define GET_ENTRY(lib, entryName) getCommonMapData(lib, entryName)
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
#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;
ICU-157 posix support for udata.. linux dll support.. posix should work with mmapped files OK X-SVN-Rev: 235
1999-11-23 04:49:35 +00:00
UErrorCode errorCode = U_ZERO_ERROR;
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
/* 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 *)icu_malloc(sizeof(UDataMemory));
if(pData==NULL) {
munmap(data, length);
return NULL;
}
pData->length = length;
pData->p =(MappedData *)data;
/* is it acceptable? */
ICU-157 fixed opening single, mapped files X-SVN-Rev: 338
1999-12-08 01:11:01 +00:00
if(NULL==getChoice(pData, NULL, DATA_TYPE, COMMON_DATA_NAME,
isCommon ? isCommonDataAcceptable : NULL, NULL, &errorCode)
) {
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
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");
}
icu_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) icu_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 *)icu_malloc(fileLength);
if(pData==NULL) {
T_FileStream_close(file);
return NULL;
}
/* read the file */
if(fileLength!=T_FileStream_read(file, pData, fileLength)) {
icu_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) {
icu_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;
}
icu_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);
}
icu_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(icu_strcmp(dataName, (const char *)(base+toc[2*number]))<0) {
limit=number;
} else {
start=number;
}
}
if(icu_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;
}
icu_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;
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
static const char *strcpy_dllentry(char *target, const char *src)
{
int i, length;
icu_strcpy(target,src);
length = icu_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 = icu_strlen(target); /* original size */
icu_strcat(target,src);
length = i + icu_strlen(src);
for(;i<length;i++)
{
if(target[i] == '-')
{
target[i] = '_';
}
}
return target;
}
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
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;
/* 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=icu_strlen(path);
icu_memcpy(pathBuffer, path, length);
basename+=length;
hasPath=TRUE;
} else {
hasPath=FALSE;
}
/* add (prefix and) basename */
# ifndef LIB_PREFIX
icu_strcpy(basename, COMMON_DATA_NAME);
suffix=basename+COMMON_DATA_NAME_LENGTH;
# else
icu_memcpy(basename, LIB_PREFIX, LIB_PREFIX_LENGTH);
icu_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=icu_strrchr(path, '/');
if(basename==NULL) {
basename=(char *)path;
} else {
++basename;
}
basename2=icu_strrchr(basename, '\\');
if(basename2!=NULL) {
basename=basename2+1;
}
if(path!=basename) {
# ifndef LIB_PREFIX
/* copy the path/basename to the path buffer */
icu_strcpy(pathBuffer, path);
basename=pathBuffer+(basename-path);
# else
/* copy the path to the path buffer */
icu_memcpy(pathBuffer, path, basename-path);
/* add prefix and basename */
suffix=pathBuffer+(basename-path);
icu_memcpy(suffix, LIB_PREFIX, LIB_PREFIX_LENGTH);
icu_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=icu_strlen(path);
icu_memcpy(pathBuffer, path, length);
suffix=pathBuffer+length;
hasPath=TRUE;
} else {
suffix=pathBuffer;
hasPath=FALSE;
}
/* add (prefix and) basename */
# ifndef LIB_PREFIX
icu_strcpy(suffix, basename);
# else
icu_memcpy(suffix, LIB_PREFIX, LIB_PREFIX_LENGTH);
icu_strcpy(suffix+LIB_PREFIX_LENGTH, basename);
# endif
basename=suffix;
}
hasBasename= *basename!=0;
if(hasBasename) {
suffix=basename+icu_strlen(basename);
}
}
path=pathBuffer;
/* set up the entry point name */
if(type!=NULL && *type!=0) {
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
#ifdef UDATA_DLL
strcpy_dllentry(entryNameBuffer, name);
#else
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
icu_strcpy(entryNameBuffer, name);
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
#endif
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
# ifdef UDATA_DLL
icu_strcat(entryNameBuffer, "_");
# else
icu_strcat(entryNameBuffer, ".");
# endif
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
#ifdef UDATA_DLL
strcat_dllentry(entryNameBuffer, type);
#else
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
icu_strcat(entryNameBuffer, type);
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
#endif
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
entryName=entryNameBuffer;
} else {
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
#ifdef UDATA_DLL
strcpy_dllentry(entryNameBuffer, name);
entryName=entryNameBuffer;
#else
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
entryName=name;
ICU-157 use _ instead of - in DLL symbols X-SVN-Rev: 266
1999-12-01 01:02:06 +00:00
#endif
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
}
/* try the common data first */
p=NULL;
# 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 */
icu_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
/* 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='_';
icu_strcpy(suffix+1, entryName);
# ifdef UDATA_DLL
icu_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 */
ICU-157 fixed opening single, mapped files X-SVN-Rev: 338
1999-12-08 01:11:01 +00:00
# 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
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
if(p==NULL) {
UNLOAD_LIBRARY(lib);
}
}
}
/* try entryName[+LIB_SUFFIX] next */
if(p==NULL) {
# ifndef LIB_PREFIX
icu_strcpy(basename, entryName);
# else
icu_strcpy(basename+LIB_PREFIX_LENGTH, entryName);
# endif
# ifdef UDATA_DLL
icu_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 */
ICU-157 fixed opening single, mapped files X-SVN-Rev: 338
1999-12-08 01:11:01 +00:00
# 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
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
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 *)icu_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) */
icu_memset(pData, 0, sizeof(pData));
# endif
pData->p=p;
return pData;
# endif
}
/* data not found */
if(U_SUCCESS(*pErrorCode)) {
ICU-157 improve UErrorCode handling X-SVN-Rev: 218
1999-11-22 19:53:19 +00:00
if(U_SUCCESS(errorCode)) {
/* file not found */
*pErrorCode=U_FILE_ACCESS_ERROR;
} else {
/* entry point not found or rejected */
*pErrorCode=errorCode;
}
ICU-157 add udata implementation X-SVN-Rev: 216
1999-11-22 19:43:01 +00:00
}
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;
}
Reference in New Issue Copy Permalink