X-Git-Url: http://git.indexdata.com/?a=blobdiff_plain;f=util%2Fcharmap.c;h=2ce85e53700ff837ce15e7397fa2b0308d5249bb;hb=6630f5b4dc744c984086bc9dd8f8b17303fa39f6;hp=08bbdb2ac467ad8982ecc713d458af2d8ee72e7d;hpb=50237e1d2713126e87d510017a4cc304a69c6798;p=idzebra-moved-to-github.git

diff --git a/util/charmap.c b/util/charmap.c
index 08bbdb2..2ce85e5 100644
--- a/util/charmap.c
+++ b/util/charmap.c
@@ -1,10 +1,19 @@
 /*
- * Copyright (C) 1996-1998, Index Data
+ * Copyright (C) 1996-1999, Index Data
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: charmap.c,v $
- * Revision 1.14  1998-10-13 20:09:18  adam
+ * 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
@@ -68,9 +77,6 @@
 #define CHR_MAXSTR 1024
 #define CHR_MAXEQUIV 32
 
-int chr_map_chrs(chr_t_entry *t, char **from, int len,
-		 int *read, char **to, int max);
-
 const char *CHR_UNKNOWN = "\001";
 const char *CHR_SPACE   = "\002";
 const char *CHR_BASE    = "\003";
@@ -78,10 +84,9 @@ const char *CHR_BASE    = "\003";
 struct chrmaptab_info
 {
     chr_t_entry *input;         /* mapping table for input data */
-    chr_t_entry *query_equiv;   /* mapping table for queries */
+    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 */
-    char **tmp_buf;
     NMEM nmem;
 };
 
@@ -90,9 +95,8 @@ struct chrmaptab_info
  */
 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 */
 };
 
 /*
@@ -112,17 +116,19 @@ static chr_t_entry *set_map_string(chr_t_entry *root, NMEM nmem,
 {
     if (!root)
     {
-	root = nmem_malloc(nmem, 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 *) nmem_strdup(nmem, 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
     {
@@ -130,7 +136,8 @@ static chr_t_entry *set_map_string(chr_t_entry *root, NMEM nmem,
 	{
 	    int i;
 
-	    root->children = nmem_malloc(nmem, 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;
 	}
@@ -142,32 +149,6 @@ static chr_t_entry *set_map_string(chr_t_entry *root, NMEM nmem,
     return root;
 }
 
-int chr_map_chrs(chr_t_entry *t, char **from, int len, int *read, char **to,
-    int max)
-{
-    int i = 0;
-    unsigned char *s;
-
-    while (len && t->children && t->children[(unsigned char) **from])
-    {
-	t = t->children[(unsigned char) **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++;
-    }
-    return i;
-}
-
-
 static chr_t_entry *find_entry(chr_t_entry *t, const char **from, int len)
 {
     chr_t_entry *res;
@@ -184,19 +165,59 @@ static chr_t_entry *find_entry(chr_t_entry *t, const char **from, int len)
 	*from = pos;
     }
     /* no children match. use ourselves, if we have a target */
-   return t->target ? t : 0;
+    return t->target ? t : 0;
+}
+
+static chr_t_entry *find_entry_x(chr_t_entry *t, const char **from, int *len)
+{
+    chr_t_entry *res;
+
+    while (*len <= 0)
+    {   /* switch to next buffer */
+	if (*len < 0)
+	    break;
+	from++;
+	len++;
+    }
+    if (*len > 0 && t->children && t->children[(unsigned char) **from])
+    {
+	const char *old_from = *from;
+	int old_len = *len;
+	
+	(*len)--;
+	(*from)++;
+	if ((res = find_entry_x(t->children[(unsigned char) *old_from],
+				from, len)))
+	    return res;
+	/* no match */
+	*len = old_len;
+	*from = old_from;
+    }
+    /* no children match. use ourselves, if we have a target */
+    return t->target ? t : 0;
+}
+
+const char **chr_map_input_x(chrmaptab maptab, const char **from, int *len)
+{
+    chr_t_entry *t = maptab->input;
+    chr_t_entry *res;
+
+    if (!(res = find_entry_x(t, from, len)))
+	abort();
+    return (const char **) (res->target);
 }
 
 const char **chr_map_input(chrmaptab maptab, const char **from, int len)
 {
     chr_t_entry *t = maptab->input;
     chr_t_entry *res;
+    int len_tmp[2];
 
-    if (!(res = find_entry(t, from, len)))
+    len_tmp[0] = len;
+    len_tmp[1] = -1;
+    if (!(res = find_entry_x(t, from, len_tmp)))
 	abort();
-    maptab->tmp_buf[0] = (char*) res->target;
-    maptab->tmp_buf[1] = NULL;
-    return (const char **) maptab->tmp_buf;
+    return (const char **) (res->target);
 }
 
 const char *chr_map_output(chrmaptab maptab, const char **from, int len)
@@ -206,27 +227,39 @@ const char *chr_map_output(chrmaptab maptab, const char **from, int len)
     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,9 +274,9 @@ static unsigned char prim(char **s)
  */
 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, tab->nmem, s, strlen(s), tmp);
     tab->output[num + tab->base_uppercase] =
@@ -256,7 +289,7 @@ static void fun_addentry(const char *s, void *data, int num)
  */
 static void fun_addspace(const char *s, void *data, int num)
 {
-    chrmaptab tab = data;
+    chrmaptab tab = (chrmaptab) data;
     tab->input = set_map_string(tab->input, tab->nmem, s, strlen(s),
 				(char*) CHR_SPACE);
 }
@@ -266,7 +299,7 @@ static void fun_addspace(const char *s, void *data, int num)
  */
 static void fun_mkstring(const char *s, void *data, int num)
 {
-    chrwork *arg = data;
+    chrwork *arg = (chrwork *) data;
     const char **res, *p = s;
 
     res = chr_map_input(arg->map, &s, strlen(s));
@@ -279,66 +312,86 @@ static void fun_mkstring(const char *s, void *data, int num)
 /*
  * Add a map to the string contained in the argument.
  */
-static void fun_addmap(const 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);
+    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)(const 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;
@@ -350,56 +403,67 @@ chrmaptab chrmaptab_create(const char *tabpath, const char *name, int map_only)
     char line[512], *argv[50];
     chrmaptab res;
     int lineno = 0;
+    int errors = 0;
     int argc, num = (int) *CHR_BASE, i;
+    NMEM nmem;
 
+    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->nmem = nmem_create ();
-    res->tmp_buf = nmem_malloc (res->nmem, sizeof(*res->tmp_buf) * 100);
-    res->input = nmem_malloc(res->nmem, sizeof(*res->input));
-    res->input->target = (unsigned char*) CHR_UNKNOWN;
-    res->input->equiv = 0;
-    res->input->children = nmem_malloc(res->nmem, 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] = nmem_malloc(res->nmem, 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 **)
+	    nmem_malloc (res->nmem, 2 * sizeof(unsigned char *));
+	res->input->children[i]->target[1] = 0;
 	if (map_only)
 	{
-	    res->input->children[i]->target = nmem_malloc (res->nmem,
-							   2 * sizeof(char));
-	    res->input->children[i]->target[0] = i;
-	    res->input->children[i]->target[1] = 0;
+	    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 = (unsigned char*) CHR_UNKNOWN;
-	res->input->children[i]->equiv = 0;
+	    res->input->children[i]->target[0] = (unsigned char*) CHR_UNKNOWN;
     }
-    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, &lineno, line, 512, argv, 50)))
+    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 *) " ";
@@ -411,20 +475,17 @@ chrmaptab chrmaptab_create(const char *tabpath, const char *name, int map_only)
 	    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 (!map_only && !yaz_matchstr(argv[0], "space"))
@@ -432,14 +493,12 @@ chrmaptab chrmaptab_create(const char *tabpath, const char *name, int map_only)
 	    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"))
@@ -448,37 +507,63 @@ chrmaptab chrmaptab_create(const char *tabpath, const char *name, int map_only)
 
 	    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
 	{
 	    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)
 {
-    nmem_destroy (tab->nmem);
-    xfree (tab);
+    if (tab)
+	nmem_destroy (tab->nmem);
 }