X-Git-Url: https://git.dlugolecki.net.pl/?a=blobdiff_plain;f=gedcom%2Fencoding.c;h=c2c3e8980686ae72d30f79d29057f988de278bb1;hb=6103dd898c4de86c68891cc0222543988a2caab7;hp=23e65bdf3324cab0badaa554d85178a540e2cfb9;hpb=4fe12100984a41d439dc9b4138d6cd8df36285f8;p=gedcom-parse.git diff --git a/gedcom/encoding.c b/gedcom/encoding.c index 23e65bd..c2c3e89 100644 --- a/gedcom/encoding.c +++ b/gedcom/encoding.c @@ -22,74 +22,92 @@ /* $Name$ */ #include -#include #include #include #include #include "gedcom_internal.h" +#include "gedcom.h" #include "encoding.h" +#include "encoding_state.h" #include "hash.h" +#include "utf8tools.h" #define ENCODING_CONF_FILE "gedcom.enc" #define GCONV_SEARCH_PATH "GCONV_PATH" #define MAXBUF 255 -static iconv_t cd_to_internal = (iconv_t) -1; -static ENCODING the_enc = ONE_BYTE; static hash_t *encodings = NULL; -char* charwidth_string[] = { "1", "2_HILO", "2_LOHI" }; +const char* charwidth_string[] = { "1", "2_HILO", "2_LOHI" }; -hnode_t *node_alloc(void *c __attribute__((unused))) +hnode_t *node_alloc(void *c UNUSED) { - return malloc(sizeof *node_alloc(NULL)); + return (hnode_t *)malloc(sizeof *node_alloc(NULL)); } -void node_free(hnode_t *n, void *c __attribute__((unused))) +void node_free(hnode_t *n, void *c UNUSED) { free((void*)hnode_getkey(n)); free(hnode_get(n)); free(n); } -void add_encoding(char *gedcom_n, char* charwidth, char *iconv_n) +void add_encoding(const char *gedcom_n, const char* charwidth, + const char *iconv_n) { char *key, *val; key = (char *) malloc(strlen(gedcom_n) + strlen(charwidth) + 3); val = (char *) malloc(strlen(iconv_n) + 1); - /* sprintf is safe here (malloc'ed before) */ - sprintf(key, "%s(%s)", gedcom_n, charwidth); - strcpy(val, iconv_n); - - if (hash_lookup(encodings, key)) { - gedcom_warning(_("Duplicate entry found for encoding '%s', ignoring"), - gedcom_n); - free(key); - free(val); - } - else { - hash_alloc_insert(encodings, key, val); + if (key && val) { + /* sprintf is safe here (malloc'ed before) */ + sprintf(key, "%s(%s)", gedcom_n, charwidth); + strcpy(val, iconv_n); + + if (hash_lookup(encodings, key)) { + gedcom_warning(_("Duplicate entry found for encoding '%s', ignoring"), + gedcom_n); + free(key); + free(val); + } + else { + hash_alloc_insert(encodings, key, val); + } } + else + MEMORY_ERROR; } -char* get_encoding(char* gedcom_n, ENCODING enc) +char* get_encoding(const char* gedcom_n, Encoding enc) { char *key; hnode_t *node; + + if (encodings == NULL) return NULL; key = (char*)malloc(strlen(gedcom_n) + strlen(charwidth_string[enc]) + 3); - /* sprintf is safe here (malloc'ed before) */ - sprintf(key, "%s(%s)", gedcom_n, charwidth_string[enc]); - node = hash_lookup(encodings, key); - free(key); - if (node) { - return hnode_get(node); + if (key) { + char* sp_pos = NULL; + while ((sp_pos = strchr(gedcom_n, ' ')) != NULL) { + *sp_pos = '_'; + } + /* sprintf is safe here (malloc'ed before) */ + sprintf(key, "%s(%s)", gedcom_n, charwidth_string[enc]); + + node = hash_lookup(encodings, key); + free(key); + if (node) { + return hnode_get(node); + } + else { + gedcom_error(_("No encoding defined for '%s'"), gedcom_n); + return NULL; + } } else { - gedcom_error(_("No encoding defined for '%s'"), gedcom_n); + MEMORY_ERROR; return NULL; } } @@ -99,6 +117,80 @@ void cleanup_encodings() hash_free(encodings); } +#ifdef USE_GLIBC_ICONV + +static char *new_gconv_path; + +void cleanup_gconv_path() +{ + /* Clean up environment */ + putenv(GCONV_SEARCH_PATH); + if (new_gconv_path) + free(new_gconv_path); +} + +/* Let function be called before main() */ +void update_gconv_search_path() __attribute__ ((constructor)); + +#endif /* USE_GLIBC_ICONV */ + +/* Note: + + The environment variable GCONV_PATH has to be adjusted before the very + first call of iconv_open. For the most general case, it means that we + have to make our own constructor here (in case some of the other library + constructors would use iconv_open). + + However, it looks like a change of an environment variable in a constructor + doesn't always survive until the main() function. This is the case if + the environment variable is a new one, for which there was no room yet + in the initial environment. The initial environment is located on the + stack, but when variables are added, it is moved to the heap (to be able + to grow). Now, the main function takes again the one from the stack, not + from the heap, so changes are lost. + + For this, the function below will also be called in gedcom_init(), which + needs to be called as early as possible in the program. + */ + +void update_gconv_search_path() +{ +#ifdef USE_GLIBC_ICONV + char *gconv_path; + /* Add gedcom data directory to gconv search path */ + gconv_path = getenv(GCONV_SEARCH_PATH); + if (gconv_path == NULL || strstr(gconv_path, PKGDATADIR) == NULL) { + if (gconv_path == NULL) { + new_gconv_path = (char *)malloc(strlen(GCONV_SEARCH_PATH) + + strlen(PKGDATADIR) + + 2); + if (new_gconv_path) + sprintf(new_gconv_path, "%s=%s", GCONV_SEARCH_PATH, PKGDATADIR); + } + else { + new_gconv_path = (char *)malloc(strlen(GCONV_SEARCH_PATH) + + strlen(gconv_path) + + strlen(PKGDATADIR) + + 3); + if (new_gconv_path) + sprintf(new_gconv_path, "%s=%s:%s", + GCONV_SEARCH_PATH, gconv_path, PKGDATADIR); + } + if (new_gconv_path) + /* Ignore failures of putenv (can't do anything about it anyway) */ + putenv(new_gconv_path); + else { + fprintf(stderr, "Could not allocate memory at %s, %d\n", + __FILE__, __LINE__); + abort(); + } + } + if (init_called && atexit(cleanup_gconv_path) != 0) { + gedcom_warning(_("Could not register path cleanup function")); + } +#endif /* USE_GLIBC_ICONV */ +} + void init_encodings() { if (encodings == NULL) { @@ -107,33 +199,11 @@ void init_encodings() char gedcom_n[MAXBUF + 1]; char charwidth[MAXBUF + 1]; char iconv_n[MAXBUF + 1]; - char *gconv_path; - atexit(cleanup_encodings); - - /* Add gedcom data directory to gconv search path */ - gconv_path = getenv(GCONV_SEARCH_PATH); - if (gconv_path == NULL || strstr(gconv_path, PKGDATADIR) == NULL) { - char *new_gconv_path; - if (gconv_path == NULL) { - new_gconv_path = (char *)malloc(strlen(GCONV_SEARCH_PATH) - + strlen(PKGDATADIR) - + 2); - sprintf(new_gconv_path, "%s=%s", GCONV_SEARCH_PATH, PKGDATADIR); - } - else { - new_gconv_path = (char *)malloc(strlen(GCONV_SEARCH_PATH) - + strlen(gconv_path) - + strlen(PKGDATADIR) - + 3); - sprintf(new_gconv_path, "%s=%s:%s", - GCONV_SEARCH_PATH, gconv_path, PKGDATADIR); - } - if (putenv(new_gconv_path) != 0) { - gedcom_warning(_("Failed updating conversion module path")); - } + if (atexit(cleanup_encodings) != 0) { + gedcom_warning(_("Could not register encoding cleanup function")); } - + encodings = hash_create(HASHCOUNT_T_MAX, NULL, NULL); hash_set_allocator(encodings, node_alloc, node_free, NULL); @@ -145,8 +215,8 @@ void init_encodings() in = fopen(path, "r"); } if (in == NULL) { - gedcom_warning(_("Could not open encoding configuration file '%s'"), - ENCODING_CONF_FILE); + gedcom_warning(_("Could not open encoding configuration file '%s': %s"), + ENCODING_CONF_FILE, strerror(errno)); } else { line_no = 1; @@ -154,6 +224,7 @@ void init_encodings() if (buffer[strlen(buffer) - 1] != '\n') { gedcom_error(_("Line too long in encoding configuration file '%s'"), ENCODING_CONF_FILE); + line_no = 0; return; } else if ((buffer[0] != '#') && (strcmp(buffer, "\n") != 0)) { @@ -163,65 +234,59 @@ void init_encodings() else { gedcom_error(_("Missing data in encoding configuration file '%s'"), ENCODING_CONF_FILE); + line_no = 0; return; } } } - fclose(in); + line_no = 0; + if (fclose(in) != 0) { + gedcom_warning(_("Error closing file '%s': %s"), + ENCODING_CONF_FILE, strerror(errno)); + } } } } -void set_encoding_width(ENCODING enc) -{ - the_enc = enc; -} - -static char conv_buf[MAXGEDCLINELEN * 2]; -static size_t conv_buf_size; +static convert_t to_int = NULL; +static char* error_value = ""; -int open_conv_to_internal(char* fromcode) +int open_conv_to_internal(const char* fromcode) { - char *encoding = get_encoding(fromcode, the_enc); - if (cd_to_internal != (iconv_t) -1) - iconv_close(cd_to_internal); - if (encoding == NULL) { - cd_to_internal = (iconv_t) -1; - } - else { - memset(conv_buf, 0, sizeof(conv_buf)); - conv_buf_size = 0; - cd_to_internal = iconv_open(INTERNAL_ENCODING, encoding); - if (cd_to_internal == (iconv_t) -1) { + convert_t new_to_int = NULL; + const char *encoding = get_encoding(fromcode, read_encoding.width); + + if (encoding != NULL) { + new_to_int = initialize_utf8_conversion(encoding, 1); + if (new_to_int == NULL) { gedcom_error(_("Error opening conversion context for encoding %s: %s"), encoding, strerror(errno)); } } - return (cd_to_internal != (iconv_t) -1); + + if (new_to_int != NULL) { + if (to_int != NULL) + cleanup_utf8_conversion(to_int); + to_int = new_to_int; + set_read_encoding(fromcode, encoding); + } + + return (new_to_int != NULL); } void close_conv_to_internal() { - iconv_close(cd_to_internal); - cd_to_internal = (iconv_t) -1; + if (to_int != NULL) { + cleanup_utf8_conversion(to_int); + to_int = NULL; + } } -char* to_internal(char* str, size_t len, - char* output_buffer, size_t out_len) + +char* to_internal(const char* str, size_t len, struct conv_buffer* output_buf) { - size_t outsize = out_len; - char *wrptr = output_buffer; - char *rdptr = conv_buf; - /* set up input buffer (concatenate to what was left previous time) */ - /* can't use strcpy, because possible null bytes from unicode */ - memcpy(conv_buf + conv_buf_size, str, len); - conv_buf_size += len; - /* set up output buffer (empty it) */ - memset(output_buffer, 0, out_len); - /* do the conversion */ - iconv(cd_to_internal, &rdptr, &conv_buf_size, &wrptr, &outsize); - /* then shift what is left over to the head of the input buffer */ - memmove(conv_buf, rdptr, conv_buf_size); - memset(conv_buf + conv_buf_size, 0, sizeof(conv_buf) - conv_buf_size); - return output_buffer; + if (conversion_set_output_buffer(to_int, output_buf)) + return convert_to_utf8_incremental(to_int, str, len); + else + return error_value; }