X-Git-Url: https://git.dlugolecki.net.pl/?a=blobdiff_plain;f=gedcom%2Fencoding.c;h=315b4adfe425e83c4bc8e1ea310551074e702a94;hb=9e93d730fa358da974e770e8778b78645e2043f9;hp=152da3007e7978ecc2e4dbbb929eb83b554bc37d;hpb=f70af63ca667358289cdbb43403ce825e8524714;p=gedcom-parse.git

diff --git a/gedcom/encoding.c b/gedcom/encoding.c
index 152da30..315b4ad 100644
--- a/gedcom/encoding.c
+++ b/gedcom/encoding.c
@@ -1,5 +1,5 @@
 /* Conversion between encodings.
-   Copyright (C) 2001 The Genes Development Team
+   Copyright (C) 2001,2002 The Genes Development Team
    This file is part of the Gedcom parser library.
    Contributed by Peter Verthez <Peter.Verthez@advalvas.be>, 2001.
 
@@ -23,103 +23,143 @@
 
 #include <string.h>
 #include <iconv.h>
-#include <search.h>
 #include <stdio.h>
 #include <limits.h>
 #include <stdlib.h>
 #include "gedcom_internal.h"
 #include "encoding.h"
+#include "hash.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 void *encoding_mapping = NULL;
 static ENCODING the_enc = ONE_BYTE;
-
-struct node {
-  char *gedcom_name;
-  char *iconv_name;
-};
+static hash_t *encodings = NULL;
 
 char* charwidth_string[] = { "1", "2_HILO", "2_LOHI" };
 
-int node_compare(const void *node1, const void *node2)
+hnode_t *node_alloc(void *c __attribute__((unused)))
 {
-  return strcmp(((const struct node *) node1)->gedcom_name,
-		((const struct node *) node2)->gedcom_name);
+  return malloc(sizeof *node_alloc(NULL));
+}
+
+void node_free(hnode_t *n, void *c __attribute__((unused)))
+{
+  free((void*)hnode_getkey(n));
+  free(hnode_get(n));
+  free(n);
 }
 
 void add_encoding(char *gedcom_n, char* charwidth, char *iconv_n)
 {
-  void **datum;
-  struct node *nodeptr = (struct node *) malloc(sizeof *nodeptr);
-  nodeptr->gedcom_name = (char *) malloc(strlen(gedcom_n)
-					 + strlen(charwidth) + 3);
-  nodeptr->iconv_name  = (char *) malloc(strlen(iconv_n) + 1);
+  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(nodeptr->gedcom_name, "%s(%s)", gedcom_n, charwidth);
-  strcpy(nodeptr->iconv_name, iconv_n);
-  datum = tsearch(nodeptr, &encoding_mapping, node_compare);
-  if ((datum == NULL) || (*datum != nodeptr)) {
+  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);
   }
 }
 
 char* get_encoding(char* gedcom_n, ENCODING enc)
 {
-  void **datum;
-  struct node search_node;
-  char *buffer;
-  buffer = (char*)malloc(strlen(gedcom_n) + strlen(charwidth_string[enc]) + 3);
+  char *key;
+  hnode_t *node;
+  
+  key = (char*)malloc(strlen(gedcom_n) + strlen(charwidth_string[enc]) + 3);
   /* sprintf is safe here (malloc'ed before) */
-  sprintf(buffer, "%s(%s)", gedcom_n, charwidth_string[enc]);
-  search_node.gedcom_name = buffer;
-  datum = tfind(&search_node, &encoding_mapping, node_compare);
-  free(buffer);
-  if (datum == NULL) {
+  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 {
-    return ((const struct node *) *datum)->iconv_name;
+}
+
+void cleanup_encodings()
+{
+  hash_free(encodings);
+}
+
+/* Let function be called before main() */
+void update_gconv_search_path() __attribute__ ((constructor));
+
+/* 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()
+{
+  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) {
+    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);
+    }
+    /* Ignore failures of putenv (can't do anything about it anyway) */
+    putenv(new_gconv_path);
   }
 }
 
 void init_encodings()
 {
-  if (encoding_mapping == NULL) {
+  if (encodings == NULL) {
     FILE *in;
     char buffer[MAXBUF + 1];
     char gedcom_n[MAXBUF + 1];
     char charwidth[MAXBUF + 1];
     char iconv_n[MAXBUF + 1];
-    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) {
-      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"));
-      }
-    }
+
+    atexit(cleanup_encodings);
+    
+    encodings = hash_create(HASHCOUNT_T_MAX, NULL, NULL);
+    hash_set_allocator(encodings, node_alloc, node_free, NULL);
     
     /* Open gedcom configuration file and read */
     in = fopen(ENCODING_CONF_FILE, "r");
@@ -193,9 +233,11 @@ void close_conv_to_internal()
 char* to_internal(char* str, size_t len,
 		  char* output_buffer, size_t out_len)
 {
+  size_t res;
   size_t outsize = out_len;
   char *wrptr = output_buffer;
   char *rdptr = conv_buf;
+  char *retval = output_buffer;
   /* 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);
@@ -203,9 +245,18 @@ char* to_internal(char* str, size_t 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);
+  res = iconv(cd_to_internal, &rdptr, &conv_buf_size, &wrptr, &outsize);
+  if (res == (size_t)-1) {
+    if (errno == EILSEQ) {
+      /* restart from an empty state and return NULL */
+      iconv(cd_to_internal, NULL, NULL, NULL, NULL);
+      retval = NULL;
+      rdptr++;
+      conv_buf_size--;
+    }
+  }
   /* 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;
+  return retval;
 }