X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=util%2Fcharmap.c;h=fc9df50251f6d111c787409c59eeb8595464c433;hb=71647c93775e998a0e602c0371c34e1143d131dd;hp=d7b214641d49dd68bfce414103bae54d406a997f;hpb=659af456d07b957cbf9ef9d94e079adf88364bc7;p=idzebra-moved-to-github.git

diff --git a/util/charmap.c b/util/charmap.c
index d7b2146..fc9df50 100644
--- a/util/charmap.c
+++ b/util/charmap.c
@@ -1,10 +1,41 @@
 /*
- * Copyright (C) 1994, Index Data I/S 
+ * Copyright (C) 1996-1999, Index Data
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: charmap.c,v $
- * Revision 1.9  1996-10-29 13:48:14  adam
+ * Revision 1.18  1999-11-30 13:48:04  adam
+ * Improved installation. Updated for inclusion of YAZ header files.
+ *
+ * Revision 1.17  1999/09/08 12:13:21  adam
+ * Fixed minor bug "replace"-mappings. Removed some logging messages.
+ *
+ * Revision 1.16  1999/09/07 07:19:21  adam
+ * Work on character mapping. Implemented replace rules.
+ *
+ * Revision 1.15  1999/05/26 07:49:14  adam
+ * C++ compilation.
+ *
+ * Revision 1.14  1998/10/13 20:09:18  adam
+ * Changed call to readconf_line.
+ *
+ * Revision 1.13  1997/10/27 14:33:06  adam
+ * Moved towards generic character mapping depending on "structure"
+ * field in abstract syntax file. Fixed a few memory leaks. Fixed
+ * bug with negative integers when doing searches with relational
+ * operators.
+ *
+ * Revision 1.12  1997/09/05 15:30:11  adam
+ * Changed prototype for chr_map_input - added const.
+ * Added support for C++, headers uses extern "C" for public definitions.
+ *
+ * Revision 1.11  1997/09/05 09:52:32  adam
+ * Extra argument added to function chr_read_maptab (tab path).
+ *
+ * Revision 1.10  1997/07/01 13:01:08  adam
+ * Bug fix in routine find_entry: didn't take into account the len arg.
+ *
+ * Revision 1.9  1996/10/29 13:48:14  adam
  * Updated to use zebrautl.h instead of alexutil.h.
  *
  * Revision 1.8  1996/10/18 12:39:23  adam
@@ -43,10 +74,8 @@
 #include <string.h>
 #include <assert.h>
 
-#include <zebrautl.h>
-#include <yaz-util.h>
+#include <yaz/yaz-util.h>
 #include <charmap.h>
-#include <tpath.h>
 
 #define CHR_MAXSTR 1024
 #define CHR_MAXEQUIV 32
@@ -55,16 +84,22 @@ const char *CHR_UNKNOWN = "\001";
 const char *CHR_SPACE   = "\002";
 const char *CHR_BASE    = "\003";
 
-extern char *data1_tabpath;
+struct chrmaptab_info
+{
+    chr_t_entry *input;         /* mapping table for input data */
+    chr_t_entry *q_input;       /* mapping table for queries */
+    unsigned char *output[256]; /* return mapping - for display of registers */
+    int base_uppercase;         /* Start of upper-case ordinals */
+    NMEM nmem;
+};
 
 /*
  * Character map trie node.
  */
 struct chr_t_entry
 {
-    chr_t_entry **children; /* array of children */
-    unsigned char *target;  /* target for this node, if any */
-    unsigned char *equiv;   /* equivalent to, or sumthin */
+    chr_t_entry **children;  /* array of children */
+    unsigned char **target;  /* target for this node, if any */
 };
 
 /*
@@ -72,29 +107,31 @@ struct chr_t_entry
  */
 typedef struct chrwork 
 {
-    chrmaptab *map;
+    chrmaptab map;
     char string[CHR_MAXSTR+1];
 } chrwork;
 
 /*
  * Add an entry to the character map.
  */
-static chr_t_entry *set_map_string(chr_t_entry *root, char *from, int len,
-    char *to)
+static chr_t_entry *set_map_string(chr_t_entry *root, NMEM nmem,
+				   const char *from, int len, char *to)
 {
     if (!root)
     {
-	root = xmalloc(sizeof(*root));
+	root = (chr_t_entry *) nmem_malloc(nmem, sizeof(*root));
 	root->children = 0;
 	root->target = 0;
     }
     if (!len)
     {
-	if (!root->target || (char*) root->target == CHR_SPACE ||
-	    (char*) root->target == CHR_UNKNOWN)
-	    root->target = (unsigned char *) xstrdup(to);
-	else if ((char*) to != CHR_SPACE)
-	    logf(LOG_DEBUG, "Character map overlap");
+	if (!root->target || !root->target[0] || strcmp(root->target[0], to))
+	{
+	    root->target = (unsigned char **)
+		nmem_malloc(nmem, sizeof(*root->target)*2);
+	    root->target[0] = (unsigned char *) nmem_strdup(nmem, to);
+	    root->target[1] = 0;
+	}
     }
     else
     {
@@ -102,133 +139,130 @@ static chr_t_entry *set_map_string(chr_t_entry *root, char *from, int len,
 	{
 	    int i;
 
-	    root->children = xmalloc(sizeof(chr_t_entry*) * 256);
+	    root->children = (chr_t_entry **)
+		nmem_malloc(nmem, sizeof(chr_t_entry*) * 256);
 	    for (i = 0; i < 256; i++)
 		root->children[i] = 0;
 	}
 	if (!(root->children[(unsigned char) *from] =
-	    set_map_string(root->children[(unsigned char) *from], from + 1,
-	    len - 1, to)))
+	    set_map_string(root->children[(unsigned char) *from], nmem,
+			   from + 1, len - 1, to)))
 	    return 0;
     }
     return root;
 }
 
-int chr_map_chrs(chr_t_entry *t, char **from, int len, int *read, char **to,
-    int max)
+static chr_t_entry *find_entry(chr_t_entry *t, const char **from, int len)
 {
-    int i = 0;
-    unsigned char *s;
+    chr_t_entry *res;
 
-    while (len && t->children && t->children[(unsigned char) **from])
+    if (len && t->children && t->children[(unsigned char) **from])
     {
-	t = t->children[(unsigned char) **from];
+	const char *pos = *from;
+
 	(*from)++;
-	len--;
-    }
-    /* if there were no matches, we are still at the root node,
-       which always has a null mapping */
-    for (s = t->target; *s && max; s++)
-    {
-	**to = *s;
-	s++;
-	(*to)++;
-	max--;
-	i++;
+	if ((res = find_entry(t->children[(unsigned char) *pos],
+	    from, len - 1)))
+	    return res;
+	/* no match */
+	*from = pos;
     }
-    return i;
+    /* no children match. use ourselves, if we have a target */
+    return t->target ? t : 0;
 }
 
-#if 1
-
-static chr_t_entry *find_entry(chr_t_entry *t, char **from, int len)
+static chr_t_entry *find_entry_x(chr_t_entry *t, const char **from, int *len)
 {
     chr_t_entry *res;
 
-    if (t->children && t->children[(unsigned char) **from])
+    while (*len <= 0)
+    {   /* switch to next buffer */
+	if (*len < 0)
+	    break;
+	from++;
+	len++;
+    }
+    if (*len > 0 && t->children && t->children[(unsigned char) **from])
     {
-	char *pos = *from;
-
+	const char *old_from = *from;
+	int old_len = *len;
+	
+	(*len)--;
 	(*from)++;
-	if ((res = find_entry(t->children[(unsigned char) *pos],
-	    from, len - 1)))
+	if ((res = find_entry_x(t->children[(unsigned char) *old_from],
+				from, len)))
 	    return res;
 	/* no match */
-	*from = pos;
+	*len = old_len;
+	*from = old_from;
     }
     /* no children match. use ourselves, if we have a target */
-   return t->target ? t : 0;
+    return t->target ? t : 0;
 }
 
-char **chr_map_input(chr_t_entry *t, char **from, int len)
+const char **chr_map_input_x(chrmaptab maptab, const char **from, int *len)
 {
-    static char *buf[2] = {0, 0};
+    chr_t_entry *t = maptab->input;
     chr_t_entry *res;
 
-    if (!(res = find_entry(t, from, len)))
+    if (!(res = find_entry_x(t, from, len)))
 	abort();
-    buf[0] = (char *) res->target;
-    return buf;
+    return (const char **) (res->target);
 }
 
-#else
-
-char **chr_map_input(chr_t_entry *t, char **from, int len)
+const char **chr_map_input(chrmaptab maptab, const char **from, int len)
 {
-    static char *buf[2] = {0, 0}, str[2] = {0, 0};
-    char *start = *from;
+    chr_t_entry *t = maptab->input;
+    chr_t_entry *res;
+    int len_tmp[2];
 
-    if (t)
-    {
-	while (len && t->children && t->children[(unsigned char) **from])
-	{
-	    t = t->children[(unsigned char) **from];
-	    (*from)++;
-	    len--;
-	}
-	buf[0] = (char*) t->target;
-    }
-    else /* null mapping */
-    {
-	if (isalnum(**from))
-	{
-	    str[0] = **from;
-	    buf[0] = str;
-	}
-	else if (isspace(**from))
-	    buf[0] = (char*) CHR_SPACE;
-	else
-	    buf[0] = (char*) CHR_UNKNOWN;
-    }
-    if (start == *from)
-	(*from)++;
-    return buf;
-    /* return (char*) t->target; */
+    len_tmp[0] = len;
+    len_tmp[1] = -1;
+    if (!(res = find_entry_x(t, from, len_tmp)))
+	abort();
+    return (const char **) (res->target);
 }
 
-#endif
+const char *chr_map_output(chrmaptab maptab, const char **from, int len)
+{
+    unsigned char c = ** (unsigned char **) from;
+    (*from)++;
+    return (const char*) maptab->output[c];
+}
 
-static unsigned char prim(char **s)
+unsigned char zebra_prim(char **s)
 {
     unsigned char c;
     unsigned int i;
-
+    
     if (**s == '\\')
     {
 	(*s)++;
 	c = **s;
 	switch (c)
 	{
-	    case '\\': c = '\\'; (*s)++; break;
-	    case 'r': c = '\r'; (*s)++; break;
-	    case 'n': c = '\n'; (*s)++; break;
-	    case 't': c = '\t'; (*s)++; break;
-	    case 's': c = ' '; (*s)++; break;
-	    case 'x': sscanf(*s, "x%2x", &i); c = i; *s += 3; break;
-	    case '{': case '[': case '(': case '}': case ']': case ')':
-	        (*s)++;
-		break;
-	    default: sscanf(*s, "%3o", &i); c = i; *s += 3; break;
+	case '\\': c = '\\'; (*s)++; break;
+	case 'r': c = '\r'; (*s)++; break;
+	case 'n': c = '\n'; (*s)++; break;
+	case 't': c = '\t'; (*s)++; break;
+	case 's': c = ' '; (*s)++; break;
+	case 'x': sscanf(*s, "x%2x", &i); c = i; *s += 3; break;
+        case '0':
+        case '1':
+        case '2':
+        case '3':
+        case '4':
+        case '5':
+        case '6':
+        case '7':
+        case '8':
+        case '9':
+	    sscanf(*s, "%3o", &i);
+            c = i;
+            *s += 3;
+            break;
+        default:
+            (*s)++;
 	}
 	return c;
     }
@@ -241,35 +275,37 @@ static unsigned char prim(char **s)
  * Callback function.
  * Add an entry to the value space.
  */
-static void fun_addentry(char *s, void *data, int num)
+static void fun_addentry(const char *s, void *data, int num)
 {
-    chrmaptab *tab = data;
+    chrmaptab tab = (chrmaptab) data;
     char tmp[2];
-
+    
     tmp[0] = num; tmp[1] = '\0';
-    tab->input = set_map_string(tab->input, s, strlen(s), tmp);
-    tab->output[num + tab->base_uppercase] = (unsigned char *) xstrdup(s);
+    tab->input = set_map_string(tab->input, tab->nmem, s, strlen(s), tmp);
+    tab->output[num + tab->base_uppercase] =
+	(unsigned char *) nmem_strdup(tab->nmem, s);
 }
 
 /* 
  * Callback function.
  * Add a space-entry to the value space.
  */
-static void fun_addspace(char *s, void *data, int num)
+static void fun_addspace(const char *s, void *data, int num)
 {
-    chrmaptab *tab = data;
-    tab->input = set_map_string(tab->input, s, strlen(s), (char*) CHR_SPACE);
+    chrmaptab tab = (chrmaptab) data;
+    tab->input = set_map_string(tab->input, tab->nmem, s, strlen(s),
+				(char*) CHR_SPACE);
 }
 
 /*
  * Create a string containing the mapped characters provided.
  */
-static void fun_mkstring(char *s, void *data, int num)
+static void fun_mkstring(const char *s, void *data, int num)
 {
-    chrwork *arg = data;
-    char **res, *p = s;
+    chrwork *arg = (chrwork *) data;
+    const char **res, *p = s;
 
-    res = chr_map_input(arg->map->input, &s, strlen(s));
+    res = chr_map_input(arg->map, &s, strlen(s));
     if (*res == (char*) CHR_UNKNOWN)
 	logf(LOG_WARN, "Map: '%s' has no mapping", p);
     strncat(arg->string, *res, CHR_MAXSTR - strlen(arg->string));
@@ -279,160 +315,193 @@ static void fun_mkstring(char *s, void *data, int num)
 /*
  * Add a map to the string contained in the argument.
  */
-static void fun_addmap(char *s, void *data, int num)
+static void fun_add_map(const char *s, void *data, int num)
 {
-    chrwork *arg = data;
+    chrwork *arg = (chrwork *) data;
 
     assert(arg->map->input);
-    set_map_string(arg->map->input, s, strlen(s), arg->string);
+    logf (LOG_DEBUG, "set map %.*s", (int) strlen(s), s);
+    set_map_string(arg->map->input, arg->map->nmem, s, strlen(s), arg->string);
+    for (s = arg->string; *s; s++)
+	logf (LOG_DEBUG, " %3d", (unsigned char) *s);
 }
 
-static int scan_string(char *s, void (*fun)(char *c, void *data, int num),
-    void *data, int *num)
+/*
+ * Add a query map to the string contained in the argument.
+ */
+static void fun_add_qmap(const char *s, void *data, int num)
 {
-    unsigned char c, str[1024], begin, end, *p;
+    chrwork *arg = (chrwork *) data;
+
+    assert(arg->map->q_input);
+    logf (LOG_DEBUG, "set qmap %.*s", (int) strlen(s), s);
+    set_map_string(arg->map->q_input, arg->map->nmem, s,
+		   strlen(s), arg->string);
+    for (s = arg->string; *s; s++)
+	logf (LOG_DEBUG, " %3d", (unsigned char) *s);
+}
 
+
+static int scan_string(char *s,
+		       void (*fun)(const char *c, void *data, int num),
+		       void *data, int *num)
+{
+    unsigned char c, str[1024], begin, end, *p;
+    
     while (*s)
     {
 	switch (*s)
 	{
-	    case '{':
-	        s++;
-	        begin = prim(&s);
-		if (*s != '-')
-		{
-		    logf(LOG_FATAL, "Bad range in char-map");
-		    return -1;
-		}
-		s++;
-		end = prim(&s);
-		if (end <= begin)
-		{
-		    logf(LOG_FATAL, "Bad range in char-map");
-		    return -1;
-		}
-		s++;
-		for (c = begin; c <= end; c++)
-		{
-		    str[0] = c; str[1] = '\0';
-		    (*fun)((char *) str, data, num ? (*num)++ : 0);
-		}
-		break;
-	    case '[': s++; abort(); break;
-	    case '(':
-		p = (unsigned char*) ++s;
+	case '{':
+	    s++;
+	    begin = zebra_prim(&s);
+	    if (*s != '-')
+	    {
+		logf(LOG_FATAL, "Bad range in char-map");
+		return -1;
+	    }
+	    s++;
+	    end = zebra_prim(&s);
+	    if (end <= begin)
+	    {
+		logf(LOG_FATAL, "Bad range in char-map");
+		return -1;
+	    }
+	    s++;
+	    for (c = begin; c <= end; c++)
+	    {
+		str[0] = c; str[1] = '\0';
+		(*fun)((char *) str, data, num ? (*num)++ : 0);
+	    }
+	    break;
+	case '[': s++; abort(); break;
+	case '(':
+	    p = (unsigned char*) ++s;
 		/* Find the end-marker, ignoring escapes */
-		do
+	    do
+	    {
+		if (!(p = (unsigned char*) strchr((char*) p, ')')))
 		{
-		    if (!(p = (unsigned char*) strchr((char*) p, ')')))
-		    {
-			logf(LOG_FATAL, "Missing ')' in string");
-			return -1;
-		    }
+		    logf(LOG_FATAL, "Missing ')' in string");
+		    return -1;
 		}
-		while (*(p -  1) == '\\');
-		*p = 0;
-		(*fun)(s, data, num ? (*num)++ : 0);
-		s = (char*) p + 1;
-		break;
-	    default:
-	        c = prim(&s);
-	        str[0] = c; str[1] = '\0';
-		(*fun)((char *) str, data, num ? (*num)++ : 0);
+	    }
+	    while (*(p -  1) == '\\');
+	    *p = 0;
+	    (*fun)(s, data, num ? (*num)++ : 0);
+	    s = (char*) p + 1;
+	    break;
+	default:
+	    c = zebra_prim(&s);
+	    str[0] = c; str[1] = '\0';
+	    (*fun)((char *) str, data, num ? (*num)++ : 0);
 	}
     }
     return 0;
 }
 
-chrmaptab *chr_read_maptab(char *name)
+chrmaptab chrmaptab_create(const char *tabpath, const char *name, int map_only)
 {
     FILE *f;
     char line[512], *argv[50];
-    chrmaptab *res = xmalloc(sizeof(*res));
+    chrmaptab res;
+    int lineno = 0;
+    int errors = 0;
     int argc, num = (int) *CHR_BASE, i;
+    NMEM nmem;
 
-    if (!(f = yaz_path_fopen(data1_tabpath, name, "r")))
+    logf (LOG_DEBUG, "maptab %s open", name);
+    if (!(f = yaz_path_fopen(tabpath, name, "r")))
     {
 	logf(LOG_WARN|LOG_ERRNO, "%s", name);
 	return 0;
     }
-    res = xmalloc(sizeof(*res));
-    res->input = xmalloc(sizeof(*res->input));
-    res->input->target = (unsigned char*) CHR_UNKNOWN;
-    res->input->equiv = 0;
-#if 1
-    res->input->children = xmalloc(sizeof(res->input) * 256);
+    nmem = nmem_create ();
+    res = (chrmaptab) nmem_malloc(nmem, sizeof(*res));
+    res->nmem = nmem;
+    res->input = (chr_t_entry *) nmem_malloc(res->nmem, sizeof(*res->input));
+    res->input->target = (unsigned char **)
+	nmem_malloc(res->nmem, sizeof(*res->input->target) * 2);
+    res->input->target[0] = (unsigned char*) CHR_UNKNOWN;
+    res->input->target[1] = 0;
+    res->input->children = (chr_t_entry **)
+	nmem_malloc(res->nmem, sizeof(res->input) * 256);
     for (i = 0; i < 256; i++)
     {
-	res->input->children[i] = xmalloc(sizeof(*res->input));
+	res->input->children[i] = (chr_t_entry *)
+	    nmem_malloc(res->nmem, sizeof(*res->input));
 	res->input->children[i]->children = 0;
-	res->input->children[i]->target = (unsigned char*) CHR_UNKNOWN;
-	res->input->children[i]->equiv = 0;
+	res->input->children[i]->target = (unsigned char **)
+	    nmem_malloc (res->nmem, 2 * sizeof(unsigned char *));
+	res->input->children[i]->target[1] = 0;
+	if (map_only)
+	{
+	    res->input->children[i]->target[0] = (unsigned char *)
+		nmem_malloc (res->nmem, 2 * sizeof(unsigned char));
+	    res->input->children[i]->target[0][0] = i;
+	    res->input->children[i]->target[0][1] = 0;
+	}
+	else
+	    res->input->children[i]->target[0] = (unsigned char*) CHR_UNKNOWN;
     }
-#else
-    res->input->children = 0;
-#endif
-    res->query_equiv = 0;
+    res->q_input = (chr_t_entry *)
+	nmem_malloc(res->nmem, sizeof(*res->q_input));
+    res->q_input->target = 0;
+    res->q_input->children = 0;
+
     for (i = *CHR_BASE; i < 256; i++)
 	res->output[i] = 0;
     res->output[(int) *CHR_SPACE] = (unsigned char *) " ";
     res->output[(int) *CHR_UNKNOWN] = (unsigned char*) "@";
     res->base_uppercase = 0;
 
-    while ((argc = readconf_line(f, line, 512, argv, 50)))
-	if (!yaz_matchstr(argv[0], "lowercase"))
+    while (!errors && (argc = readconf_line(f, &lineno, line, 512, argv, 50)))
+	if (!map_only && !yaz_matchstr(argv[0], "lowercase"))
 	{
 	    if (argc != 2)
 	    {
 		logf(LOG_FATAL, "Syntax error in charmap");
-		fclose(f);
-		return 0;
+		++errors;
 	    }
 	    if (scan_string(argv[1], fun_addentry, res, &num) < 0)
 	    {
 		logf(LOG_FATAL, "Bad value-set specification");
-		fclose(f);
-		return 0;
+		++errors;
 	    }
 	    res->base_uppercase = num;
 	    res->output[(int) *CHR_SPACE + num] = (unsigned char *) " ";
 	    res->output[(int) *CHR_UNKNOWN + num] = (unsigned char*) "@";
 	    num = (int) *CHR_BASE;
 	}
-	else if (!yaz_matchstr(argv[0], "uppercase"))
+	else if (!map_only && !yaz_matchstr(argv[0], "uppercase"))
 	{
 	    if (!res->base_uppercase)
 	    {
 		logf(LOG_FATAL, "Uppercase directive with no lowercase set");
-		fclose(f);
-		return 0;
+		++errors;
 	    }
 	    if (argc != 2)
 	    {
-		logf(LOG_FATAL, "Syntax error in charmap");
-		fclose(f);
-		return 0;
+		logf(LOG_FATAL, "Missing arg for uppercase directive");
+		++errors;
 	    }
 	    if (scan_string(argv[1], fun_addentry, res, &num) < 0)
 	    {
 		logf(LOG_FATAL, "Bad value-set specification");
-		fclose(f);
-		return 0;
+		++errors;
 	    }
 	}
-	else if (!yaz_matchstr(argv[0], "space"))
+	else if (!map_only && !yaz_matchstr(argv[0], "space"))
 	{
 	    if (argc != 2)
 	    {
 		logf(LOG_FATAL, "Syntax error in charmap");
-		fclose(f);
-		return 0;
+		++errors;
 	    }
 	    if (scan_string(argv[1], fun_addspace, res, 0) < 0)
 	    {
 		logf(LOG_FATAL, "Bad space specification");
-		fclose(f);
-		return 0;
+		++errors;
 	    }
 	}
 	else if (!yaz_matchstr(argv[0], "map"))
@@ -441,33 +510,63 @@ chrmaptab *chr_read_maptab(char *name)
 
 	    if (argc != 3)
 	    {
-		logf(LOG_FATAL, "charmap MAP directive requires 2 args");
-		fclose(f);
-		return 0;
+		logf(LOG_FATAL, "charmap directive map requires 2 args");
+		++errors;
 	    }
 	    buf.map = res;
 	    buf.string[0] = '\0';
 	    if (scan_string(argv[2], fun_mkstring, &buf, 0) < 0)
 	    {
 		logf(LOG_FATAL, "Bad map target");
-		fclose(f);
-		return 0;
+		++errors;
 	    }
-	    if (scan_string(argv[1], fun_addmap, &buf, 0) < 0)
+	    if (scan_string(argv[1], fun_add_map, &buf, 0) < 0)
 	    {
 		logf(LOG_FATAL, "Bad map source");
-		fclose(f);
-		return 0;
+		++errors;
+	    }
+	}
+	else if (!yaz_matchstr(argv[0], "qmap"))
+	{
+	    chrwork buf;
+
+	    if (argc != 3)
+	    {
+		logf(LOG_FATAL, "charmap directive qmap requires 2 args");
+		++errors;
+	    }
+	    buf.map = res;
+	    buf.string[0] = '\0';
+	    if (scan_string(argv[2], fun_mkstring, &buf, 0) < 0)
+	    {
+		logf(LOG_FATAL, "Bad qmap target");
+		++errors;
+	    }
+	    if (scan_string(argv[1], fun_add_qmap, &buf, 0) < 0)
+	    {
+		logf(LOG_FATAL, "Bad qmap source");
+		++errors;
 	    }
 	}
 	else
 	{
-#if 0
-	    logf(LOG_WARN, "Syntax error at '%s' in %s", line, file);
-	    fclose(f);
-	    return 0;
-#endif
+	    logf(LOG_WARN, "Syntax error at '%s' in %s", line, name);
 	}
+    
     fclose(f);
+    if (errors)
+    {
+	chrmaptab_destroy(res);
+	res = 0;
+    }
+    logf (LOG_DEBUG, "maptab %s close %d errors", name, errors);
     return res;
 }
+
+void chrmaptab_destroy(chrmaptab tab)
+{
+    if (tab)
+	nmem_destroy (tab->nmem);
+}
+
+