#include <limits.h>
#include <stdlib.h>
#include "gedcom_internal.h"
+#include "gedcom.h"
#include "encoding.h"
#include "hash.h"
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)))
{
- return malloc(sizeof *node_alloc(NULL));
+ return (hnode_t *)malloc(sizeof *node_alloc(NULL));
}
void node_free(hnode_t *n, void *c __attribute__((unused)))
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;
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) {
+ /* 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;
}
}
+static char *new_gconv_path;
+
void cleanup_encodings()
{
hash_free(encodings);
+ /* Clean up environment */
+ putenv(GCONV_SEARCH_PATH);
+ if (new_gconv_path)
+ free(new_gconv_path);
}
/* Let function be called before main() */
/* 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);
+ 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);
- sprintf(new_gconv_path, "%s=%s:%s",
- GCONV_SEARCH_PATH, gconv_path, PKGDATADIR);
+ 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();
}
- /* Ignore failures of putenv (can't do anything about it anyway) */
- putenv(new_gconv_path);
}
}
char charwidth[MAXBUF + 1];
char iconv_n[MAXBUF + 1];
- atexit(cleanup_encodings);
+ 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);
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;
}
}
}
- fclose(in);
+ if (fclose(in) != 0) {
+ gedcom_warning(_("Error closing file '%s': %s"),
+ ENCODING_CONF_FILE, strerror(errno));
+ }
}
}
}
static char conv_buf[MAXGEDCLINELEN * 2];
static size_t conv_buf_size;
-int open_conv_to_internal(char* fromcode)
+int open_conv_to_internal(const char* fromcode)
{
- char *encoding = get_encoding(fromcode, the_enc);
+ const char *encoding = get_encoding(fromcode, the_enc);
if (cd_to_internal != (iconv_t) -1)
iconv_close(cd_to_internal);
if (encoding == NULL) {
void close_conv_to_internal()
{
- iconv_close(cd_to_internal);
+ if (iconv_close(cd_to_internal) != 0) {
+ gedcom_warning(_("Error closing conversion context: %s"), strerror(errno));
+ }
cd_to_internal = (iconv_t) -1;
}
-char* to_internal(char* str, size_t len,
+char* to_internal(const char* str, size_t len,
char* output_buffer, size_t out_len)
{
size_t res;
rdptr++;
conv_buf_size--;
}
+ else if (errno == EINVAL) {
+ /* Do nothing, leave it to next iteration */
+ }
+ else {
+ gedcom_error(_("Error in converting characters: %s"), strerror(errno));
+ }
}
/* then shift what is left over to the head of the input buffer */
memmove(conv_buf, rdptr, conv_buf_size);
projects / gedcom-parse.git / blobdiff