static PyObject *t_resourcebundle_setAppData(PyTypeObject *type,
PyObject *args)
{
charsArg packageName, path;
if (!parseArgs(args, "nf", &packageName, &path))
{
HANDLE fd = CreateFile(path, GENERIC_READ, FILE_SHARE_READ,
NULL, OPEN_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
UErrorCode status = U_ZERO_ERROR;
DWORD dwSize;
HANDLE hMap;
LPVOID data;
if (fd == INVALID_HANDLE_VALUE)
return PyErr_SetFromWindowsErrWithFilename(0, path);
dwSize = GetFileSize(fd, NULL);
if (dwSize == INVALID_FILE_SIZE)
{
PyErr_SetFromWindowsErrWithFilename(0, path);
CloseHandle(fd);
return NULL;
}
hMap = CreateFileMapping(fd, NULL, PAGE_READONLY, 0, dwSize, NULL);
if (!hMap)
{
PyErr_SetFromWindowsErrWithFilename(0, path);
CloseHandle(fd);
return NULL;
}
CloseHandle(fd);
data = MapViewOfFile(hMap, FILE_MAP_READ, 0, 0, 0);
if (!data)
{
PyErr_SetFromWindowsErrWithFilename(0, path);
CloseHandle(hMap);
return NULL;
}
CloseHandle(hMap);
udata_setAppData(packageName, data, &status);
if (U_FAILURE(status))
{
UnmapViewOfFile(data);
return ICUException(status).reportError();
}
Py_RETURN_NONE;
}
return PyErr_SetArgsError(type, "setAppData", args);
}
static void setAppData()
{
static bool setAppDataDone = false;
if (setAppDataDone)
{
return;
}
else
{
setAppDataDone = true;
UErrorCode err = U_ZERO_ERROR;
#if defined(_WIN32) || defined(WIN32)
udata_setAppData("XercesMessages2_8", &XercesMessages2_8_dat, &err);
#else
udata_setAppData("XercesMessages2_8_0", &XercesMessages2_8_0_dat, &err);
#endif
if (U_SUCCESS(err))
{
setAppDataOK = true;
}
}
}
static void initMsg(const char *pname) {
static int ps = 0;
if (!ps) {
char dataPath[2048]; /* XXX Sloppy: should be PATH_MAX. */
UErrorCode err = U_ZERO_ERROR;
ps = 1;
/* Set up our static data - if any */
#ifdef UCONVMSG_LINK
udata_setAppData(UCONVMSG, (const void*) uconvmsg_dat, &err);
if (U_FAILURE(err)) {
fprintf(stderr, "%s: warning, problem installing our static resource bundle data uconvmsg: %s - trying anyways.\n",
pname, u_errorName(err));
err = U_ZERO_ERROR; /* It may still fail */
}
#endif
/* Get messages. */
gBundle = u_wmsg_setPath(UCONVMSG, &err);
if (U_FAILURE(err)) {
fprintf(stderr,
"%s: warning: couldn't open bundle %s: %s\n",
pname, UCONVMSG, u_errorName(err));
#ifdef UCONVMSG_LINK
fprintf(stderr,
"%s: setAppData was called, internal data %s failed to load\n",
pname, UCONVMSG);
#endif
err = U_ZERO_ERROR;
/* that was try #1, try again with a path */
uprv_strcpy(dataPath, u_getDataDirectory());
uprv_strcat(dataPath, U_FILE_SEP_STRING);
uprv_strcat(dataPath, UCONVMSG);
gBundle = u_wmsg_setPath(dataPath, &err);
if (U_FAILURE(err)) {
fprintf(stderr,
"%s: warning: still couldn't open bundle %s: %s\n",
pname, dataPath, u_errorName(err));
fprintf(stderr, "%s: warning: messages will not be displayed\n", pname);
}
}
}
}
static PyObject *t_resourcebundle_setAppData(PyTypeObject *type,
PyObject *args)
{
charsArg packageName, path;
if (!parseArgs(args, "nf", &packageName, &path))
{
int fd = open(path, O_RDONLY);
UErrorCode status = U_ZERO_ERROR;
struct stat buf;
void *data;
if (fd < 0)
return PyErr_SetFromErrnoWithFilename(PyExc_ValueError, path);
if (fstat(fd, &buf) < 0)
{
PyErr_SetFromErrnoWithFilename(PyExc_ValueError, path);
close(fd);
return NULL;
}
data = mmap(NULL, buf.st_size, PROT_READ, MAP_SHARED, fd, 0);
if (data == MAP_FAILED)
{
PyErr_SetFromErrnoWithFilename(PyExc_ValueError, path);
close(fd);
return NULL;
}
close(fd);
udata_setAppData(packageName, data, &status);
if (U_FAILURE(status))
{
munmap(data, buf.st_size);
return ICUException(status).reportError();
}
Py_RETURN_NONE;
}
return PyErr_SetArgsError(type, "setAppData", args);
}
static void setAppData()
{
static bool setAppDataDone = false;
if (setAppDataDone)
{
return;
}
else
{
setAppDataDone = true;
UErrorCode err = U_ZERO_ERROR;
udata_setAppData(BUNDLE_NAME, &ENTRY_POINT, &err);
if (U_SUCCESS(err))
{
setAppDataOK = true;
}
}
}
Bool
CodeSet_Init(const char *icuDataDir) // IN: ICU data file location in Current code page.
// Default is used if NULL.
{
#ifdef NO_ICU
/* Nothing required if not using ICU. */
return TRUE;
#else // NO_ICU
DynBuf dbpath;
#ifdef _WIN32
DWORD attribs;
utf16_t *modPath = NULL;
utf16_t *lastSlash;
utf16_t *wpath;
HANDLE hFile = INVALID_HANDLE_VALUE;
HANDLE hMapping = NULL;
void *memMappedData = NULL;
#else
struct stat finfo;
#endif
char *path = NULL;
Bool ret = FALSE;
DynBuf_Init(&dbpath);
#ifdef USE_ICU
/*
* We're using system ICU, which finds its own data. So nothing to
* do here.
*/
dontUseIcu = FALSE;
ret = TRUE;
goto exit;
#endif
/*
* ********************* WARNING
* Must avoid recursive calls into the codeset library here, hence
* the idiotic hoop-jumping. DO NOT change any of these calls to
* wrapper equivalents or call any other functions that may perform
* string conversion.
* ********************* WARNING
*/
#ifdef _WIN32 // {
#if vmx86_devel && !defined(TEST_CUSTOM_ICU_DATA_FILE)
/*
* Devel builds use toolchain directory first.
*/
{
WCHAR icuFilePath[MAX_PATH] = { 0 };
DWORD n = ExpandEnvironmentStringsW(ICU_DATA_FILE_PATH,
icuFilePath, ARRAYSIZE(icuFilePath));
if (n > 0 && n < ARRAYSIZE(icuFilePath)) {
attribs = GetFileAttributesW(icuFilePath);
if ((INVALID_FILE_ATTRIBUTES != attribs) ||
(attribs & FILE_ATTRIBUTE_DIRECTORY) == 0) {
if (!CodeSetOld_Utf16leToCurrent((const char *) icuFilePath,
n * sizeof *icuFilePath,
&path, NULL)) {
goto exit;
}
goto found;
}
}
}
#endif
if (icuDataDir) {
/*
* Data file must be in the specified directory.
*/
size_t length = strlen(icuDataDir);
if (!DynBuf_Append(&dbpath, icuDataDir, length)) {
goto exit;
}
if (length && icuDataDir[length - 1] != DIRSEPC) {
if (!DynBuf_Append(&dbpath, DIRSEPS, strlen(DIRSEPS))) {
goto exit;
}
}
if (!DynBuf_Append(&dbpath, ICU_DATA_FILE, strlen(ICU_DATA_FILE)) ||
!DynBuf_Append(&dbpath, "\0", 1)) {
goto exit;
}
/*
* Check for file existence.
*/
attribs = GetFileAttributesA(DynBuf_Get(&dbpath));
if ((INVALID_FILE_ATTRIBUTES == attribs) ||
(attribs & FILE_ATTRIBUTE_DIRECTORY)) {
goto exit;
}
path = (char *) DynBuf_Detach(&dbpath);
} else {
/*
* Data file must be in the directory of the current module
* (i.e. the module that contains CodeSet_Init()).
*/
HMODULE hModule = W32Util_GetModuleByAddress((void *) CodeSet_Init);
if (!hModule) {
goto exit;
}
modPath = CodeSetGetModulePath(hModule);
if (!modPath) {
goto exit;
}
lastSlash = wcsrchr(modPath, DIRSEPC_W);
if (!lastSlash) {
goto exit;
}
*lastSlash = L'\0';
if (!DynBuf_Append(&dbpath, modPath,
wcslen(modPath) * sizeof(utf16_t)) ||
!DynBuf_Append(&dbpath, DIRSEPS_W,
wcslen(DIRSEPS_W) * sizeof(utf16_t)) ||
!DynBuf_Append(&dbpath, ICU_DATA_FILE_W,
wcslen(ICU_DATA_FILE_W) * sizeof(utf16_t)) ||
!DynBuf_Append(&dbpath, L"\0", 2)) {
goto exit;
}
/*
* Since u_setDataDirectory can't handle UTF-16, we would have to
* now convert this path to local encoding. But that fails when
* the module is in a path containing characters not in the
* local encoding (see 282524). So we'll memory-map the file
* instead and call udata_setCommonData() below.
*/
wpath = (utf16_t *) DynBuf_Get(&dbpath);
hFile = CreateFileW(wpath, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0,
NULL);
if (INVALID_HANDLE_VALUE == hFile) {
goto exit;
}
hMapping = CreateFileMapping(hFile, NULL, PAGE_READONLY, 0, 0, NULL);
if (NULL == hMapping) {
goto exit;
}
memMappedData = MapViewOfFile(hMapping, FILE_MAP_READ, 0, 0, 0);
if (NULL == memMappedData) {
goto exit;
}
}
#else // } _WIN32 {
#if vmx86_devel && !defined(TEST_CUSTOM_ICU_DATA_FILE)
{
char *modPath;
char *lastSlash;
/*
* Devel builds use toolchain directory first.
*/
if (stat(ICU_DATA_FILE_PATH, &finfo) >= 0 && !S_ISDIR(finfo.st_mode)) {
if ((path = strdup(ICU_DATA_FILE_PATH)) == NULL) {
goto exit;
}
goto found;
}
/*
* Then we try module directory, if we can get it.
*/
modPath = CodeSetGetModulePath(HGMP_PRIVILEGE);
if (modPath) {
lastSlash = strrchr(modPath, DIRSEPC);
if (lastSlash) {
*lastSlash = '\0';
if (DynBuf_Append(&dbpath, modPath, strlen(modPath)) &&
DynBuf_Append(&dbpath, DIRSEPS, strlen(DIRSEPS)) &&
DynBuf_Append(&dbpath, ICU_DATA_FILE,
strlen(ICU_DATA_FILE)) &&
DynBuf_Append(&dbpath, "\0", 1)) {
if ((stat((const char *) DynBuf_Get(&dbpath), &finfo) >= 0) &&
!S_ISDIR(finfo.st_mode)) {
free(modPath);
path = DynBuf_Detach(&dbpath);
goto found;
} else {
DynBuf_SetSize(&dbpath, 0);
}
}
}
free(modPath);
}
}
#endif // vmx86_devel
if (icuDataDir) {
/* Use the caller-specified ICU data dir. */
if (!DynBuf_Append(&dbpath, icuDataDir, strlen(icuDataDir))) {
goto exit;
}
} else {
/* Use a default ICU data dir. */
# if defined __APPLE__
Location_GetLibrary_Type *Location_GetLibrary =
Location_GetLibrary_Addr();
if (Location_GetLibrary) {
char *libDir = Location_GetLibrary();
Bool success = libDir
&& DynBuf_Append(&dbpath, libDir, strlen(libDir));
free(libDir);
if (!success) {
goto exit;
}
} else
# endif
{
if (!DynBuf_Append(&dbpath, POSIX_ICU_DIR, strlen(POSIX_ICU_DIR))) {
goto exit;
}
}
if (!DynBuf_Append(&dbpath, "/icu", strlen("/icu"))) {
goto exit;
}
}
if (!DynBuf_Append(&dbpath, DIRSEPS, strlen(DIRSEPS)) ||
!DynBuf_Append(&dbpath, ICU_DATA_FILE, strlen(ICU_DATA_FILE)) ||
!DynBuf_Append(&dbpath, "\0", 1)) {
goto exit;
}
/*
* Check for file existence. (DO NOT CHANGE TO 'stat' WRAPPER).
*/
path = (char *) DynBuf_Detach(&dbpath);
if (stat(path, &finfo) < 0 || S_ISDIR(finfo.st_mode)) {
goto exit;
}
#endif // } _WIN32
#if vmx86_devel && !defined(TEST_CUSTOM_ICU_DATA_FILE)
found:
#endif
#ifdef _WIN32
if (memMappedData) {
/*
* Tell ICU to use this mapped data.
*/
UErrorCode uerr = U_ZERO_ERROR;
ASSERT(memMappedData);
udata_setCommonData(memMappedData, &uerr);
if (uerr != U_ZERO_ERROR) {
UnmapViewOfFile(memMappedData);
goto exit;
}
udata_setAppData(ICU_DATA_ITEM, memMappedData, &uerr);
if (uerr != U_ZERO_ERROR) {
UnmapViewOfFile(memMappedData);
goto exit;
}
} else {
#endif
/*
* Tell ICU to use this directory.
*/
u_setDataDirectory(path);
#ifdef _WIN32
}
#endif
dontUseIcu = FALSE;
ret = TRUE;
exit:
if (!ret) {
/*
* There was an error initing ICU, but if we can fall back on
* non-ICU (old CodeSet) then things are OK.
*/
if (CODESET_CAN_FALLBACK_ON_NON_ICU) {
ret = TRUE;
dontUseIcu = TRUE;
#ifdef _WIN32
OutputDebugStringW(L"CodeSet_Init: no ICU\n");
#endif
}
}
#ifdef _WIN32
free(modPath);
if (hMapping) {
CloseHandle(hMapping);
}
if (hFile != INVALID_HANDLE_VALUE) {
CloseHandle(hFile);
}
#endif
free(path);
DynBuf_Destroy(&dbpath);
return ret;
#endif
}
static void TestUDataSetAppData(){
/* UDataMemory *dataItem;*/
UErrorCode status=U_ZERO_ERROR;
int fileHandle = 0; /* We are going to read the testdata.dat file */
struct stat statBuf;
size_t fileSize = 0;
char *fileBuf = 0;
size_t i;
/* Open the testdata.dat file, using normal */
const char* tdrelativepath = loadTestData(&status);
char* filePath=(char*)malloc(sizeof(char) * (strlen(tdrelativepath) + strlen(".dat") +1 +strlen(tdrelativepath)) );
strcpy(filePath, tdrelativepath);
strcat(filePath, ".dat");
log_verbose("Testing udata_setAppData() with %s\n", filePath);
#if defined(WIN32) || defined(U_CYGWIN)
fileHandle = open( filePath, O_RDONLY | O_BINARY );
#else
fileHandle = open( filePath, O_RDONLY);
#endif
if( fileHandle == -1 ) {
log_err("FAIL: TestUDataSetAppData() can not open(\"%s\", O_RDONLY)\n", filePath);
goto cleanupAndReturn;
}
/*
*Find the size of testdata.dat, and read the whole thing into memory
*/
if (fstat(fileHandle, &statBuf) == 0) {
fileSize = statBuf.st_size;
}
if (fileSize == 0) {
log_err("FAIL: TestUDataSetAppData() can not find size of file \"%s\".\n", filePath);
goto cleanupAndReturn;
}
fileBuf = (char *)ctst_malloc(fileSize);
if (fileBuf == 0) {
log_err("FAIL: TestUDataSetAppData() can not malloc(%d) for file \"%s\".\n", fileSize, filePath);
goto cleanupAndReturn;
}
i = read(fileHandle, fileBuf, fileSize);
if (i != fileSize) {
log_err("FAIL: TestUDataSetAppData() error reading file \"%s\" size=%d read=%d.\n", filePath, fileSize, i);
goto cleanupAndReturn;
}
/*
* Got testdata.dat into memory, now we try setAppData using the memory image.
*/
status=U_ZERO_ERROR;
udata_setAppData("appData1", fileBuf, &status);
if (status != U_ZERO_ERROR) {
log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData1\", fileBuf, status) "
" returned status of %s\n", u_errorName(status));
goto cleanupAndReturn;
}
udata_setAppData("appData2", fileBuf, &status);
if (status != U_ZERO_ERROR) {
log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData2\", fileBuf, status) "
" returned status of %s\n", u_errorName(status));
goto cleanupAndReturn;
}
/* If we try to setAppData with the same name a second time, we should get a
* a using default warning.
*/
udata_setAppData("appData2", fileBuf, &status);
if (status != U_USING_DEFAULT_WARNING) {
log_err("FAIL: TestUDataSetAppData(): udata_setAppData(\"appData2\", fileBuf, status) "
" returned status of %s, expected U_USING_DEFAULT_WARNING.\n", u_errorName(status));
}
/** It is no longer correct to use udata_setAppData to change the
package of a contained item.
dataItem = udata_open("appData1", "res", "te_IN", &status); **/
cleanupAndReturn:
/* Note: fileBuf is not deleted because ICU retains a pointer to it
* forever (until ICU is shut down).
*/
if (fileHandle > 0) {
close(fileHandle);
}
free(filePath);
return;
}
/*
* main() This one function is all of the application code.
*/
int main(int argc, char **argv)
{
UBool displayUsage = FALSE; /* Set true if command line err or help */
/* option was requested. */
UBool verbose = FALSE; /* Set true if -v command line option. */
char *optionError = NULL; /* If command line contains an unrecognized */
/* option, this will point to it. */
char *locale=NULL; /* Locale name. Null for system default, */
/* otherwise set from command line. */
const char * programName = argv[0]; /* Program invocation name. */
UFILE *u_stdout; /* Unicode stdout file. */
UErrorCode err = U_ZERO_ERROR; /* Error return, used for most ICU */
/* functions. */
UResourceBundle *myResources; /* ICU Resource "handles" */
UResourceBundle *fortunes_r;
int32_t numFortunes; /* Number of fortune strings available. */
int i;
const UChar *resString; /* Points to strings fetched from Resources. */
int32_t len;
/* Process command line options.
* -l locale specify a locale
* -v verbose mode. Display extra messages.
* -? or --help display a usage line
*/
for (i=1; i<argc; i++) {
if (strcmp(argv[i], "-l") ==0) {
if (++i < argc) {
locale = argv[i];
}
continue;
}
if (strcmp(argv[i], "-v") == 0) {
verbose = TRUE;
continue;}
if (strcmp(argv[i], "-?") == 0 ||
strcmp(argv[i], "--help") == 0) {
displayUsage = TRUE;
continue;}
optionError = argv[i];
displayUsage = TRUE;
break;
}
/* ICU's icuio package provides a convenient way to write Unicode
* data to stdout. The string data that we get from resources
* will be UChar * strings, which icuio can handle nicely.
*/
u_stdout = u_finit(stdout, NULL /*locale*/, NULL /*codepage */);
if (verbose) {
u_fprintf(u_stdout, "%s: checking output via icuio.\n", programName);
}
#ifndef UFORTUNE_NOSETAPPDATA
/* Tell ICU where our resource data is located in memory.
* The data lives in the Fortune_Resources dll, and we just
* pass the address of an exported symbol from that library
* to ICU.
*/
udata_setAppData("fortune_resources", &fortune_resources_dat, &err);
if (U_FAILURE(err)) {
fprintf(stderr, "%s: udata_setAppData failed with error \"%s\"\n", programName, u_errorName(err));
exit(-1);
}
#endif
/* Open our resources.
*/
myResources = ures_open("fortune_resources", locale, &err);
if (U_FAILURE(err)) {
fprintf(stderr, "%s: ures_open failed with error \"%s\"\n", programName, u_errorName(err));
exit(-1);
}
if (verbose) {
u_fprintf(u_stdout, "status from ures_open(\"fortune_resources\", %s) is %s\n",
locale? locale: " ", u_errorName(err));
}
/*
* Display any command line option usage errors and/or the
* usage help message. These messages come from our resource bundle.
*/
if (optionError != NULL) {
const UChar *msg = ures_getStringByKey(myResources, "optionMessage", &len, &err);
if (U_FAILURE(err)) {
fprintf(stderr, "%s: ures_getStringByKey(\"optionMessage\") failed, %s\n",
programName, u_errorName(err));
exit(-1);
}
u_file_write(msg, len, u_stdout); /* msg is UChar *, from resource */
u_fprintf(u_stdout, " %s\n", optionError); /* optionError is char *, from argv */
}
if (displayUsage) {
const UChar *usage;
int returnValue=0;
usage = ures_getStringByKey(myResources, "usage", &len, &err);
if (U_FAILURE(err)) {
fprintf(stderr, "%s: ures_getStringByKey(\"usage\") failed, %s\n", programName, u_errorName(err));
exit(-1);
}
u_file_write(usage, len, u_stdout);
if (optionError != NULL) {returnValue = -1;}
return returnValue;
}
/*
* Open the "fortunes" resources from within the already open resources
*/
fortunes_r = ures_getByKey(myResources, "fortunes", NULL, &err);
if (U_FAILURE(err)) {
fprintf(stderr, "%s: ures_getByKey(\"fortunes\") failed, %s\n", programName, u_errorName(err));
exit(-1);
}
/*
* Pick up and display a random fortune
*
*/
numFortunes = ures_countArrayItems(myResources, "fortunes", &err);
if (U_FAILURE(err)) {
fprintf(stderr, "%s: ures_countArrayItems(\"fortunes\") failed, %s\n", programName, u_errorName(err));
exit(-1);
}
if (numFortunes <= 0) {
fprintf(stderr, "%s: no fortunes found.\n", programName);
exit(-1);
}
i = (int)time(NULL) % numFortunes; /* Use time to pick a somewhat-random fortune. */
resString = ures_getStringByIndex(fortunes_r, i, &len, &err);
if (U_FAILURE(err)) {
fprintf(stderr, "%s: ures_getStringByIndex(%d) failed, %s\n", programName, i, u_errorName(err));
exit(-1);
}
u_file_write(resString, len, u_stdout); /* Write out the message */
u_fputc(0x0a, u_stdout); /* and a trailing newline */
return 0;
}
