From db9513f9eca4ef13d3cea779a695bb822fd973a9 Mon Sep 17 00:00:00 2001
From: Adam Dickmeiss <adam@indexdata.dk>
Date: Tue, 13 Oct 1998 16:09:45 +0000
Subject: [PATCH] Added support for arbitrary OID's for tagsets, schemas and
 attribute sets. Added support for multiple attribute set
 references and tagset references from an abstract syntax
 file. Fixed many bad logs-calls in routines that read the
 various specifications regarding data1 (*.abs,*.att,...)
 and made the messages consistent whenever possible. Added
 extra 'lineno' argument to function readconf_line.

---
 include/d1_attset.h   |    4 +-
 include/data1.h       |   12 +-
 retrieval/d1_absyn.c  |  341 ++++++++++++++++++++++++++-----------------------
 retrieval/d1_attset.c |  146 +++++++++++----------
 retrieval/d1_espec.c  |  134 +++++++++++--------
 retrieval/d1_map.c    |   53 +++++---
 retrieval/d1_marc.c   |   63 +++++----
 retrieval/d1_tagset.c |  135 ++++++++++----------
 retrieval/d1_varset.c |   70 +++++-----
 util/readconf.c       |   32 +++--
 10 files changed, 564 insertions(+), 426 deletions(-)

diff --git a/include/d1_attset.h b/include/d1_attset.h
index 013bfa3..82f0531 100644
--- a/include/d1_attset.h
+++ b/include/d1_attset.h
@@ -75,7 +75,7 @@ struct data1_attset
     oid_value reference;   /* external ID of attset */
     data1_att *atts;          /* attributes */
     data1_attset_child *children;  /* included attset */
-    data1_attset *next;       /* sibling */
+    data1_attset *next;       /* next in cache */
 };
 
 typedef struct data1_handle_info *data1_handle;
@@ -84,6 +84,8 @@ YAZ_EXPORT data1_att *data1_getattbyname(data1_handle dh, data1_attset *s,
 					 char *name);
 YAZ_EXPORT data1_attset *data1_read_attset(data1_handle dh, const char *file);
 
+YAZ_EXPORT data1_attset *data1_empty_attset(data1_handle dh);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/data1.h b/include/data1.h
index 3deae89..d5dc4e7 100644
--- a/include/data1.h
+++ b/include/data1.h
@@ -24,7 +24,16 @@
  * OF THIS SOFTWARE.
  *
  * $Log: data1.h,v $
- * Revision 1.36  1998-05-18 13:06:57  adam
+ * Revision 1.37  1998-10-13 16:09:46  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.36  1998/05/18 13:06:57  adam
  * Changed the way attribute sets are handled by the retriaval module.
  * Extended Explain conversion / schema.
  * Modified server and client to work with ASN.1 compiled protocol handlers.
@@ -444,6 +453,7 @@ YAZ_EXPORT data1_node *data1_read_record(data1_handle dh,
 YAZ_EXPORT data1_absyn *data1_read_absyn(data1_handle dh, const char *file);
 YAZ_EXPORT data1_tag *data1_gettagbynum(data1_handle dh, data1_tagset *s,
 					int type, int value);
+YAZ_EXPORT data1_tagset *data1_empty_tagset (data1_handle dh);
 YAZ_EXPORT data1_tagset *data1_read_tagset(data1_handle dh, char *file);
 YAZ_EXPORT data1_element *data1_getelementbytagname(data1_handle dh, 
 						    data1_absyn *abs,
diff --git a/retrieval/d1_absyn.c b/retrieval/d1_absyn.c
index 7813015..6b9a413 100644
--- a/retrieval/d1_absyn.c
+++ b/retrieval/d1_absyn.c
@@ -4,7 +4,16 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: d1_absyn.c,v $
- * Revision 1.21  1998-06-09 13:55:07  adam
+ * Revision 1.22  1998-10-13 16:09:47  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.21  1998/06/09 13:55:07  adam
  * Minor changes.
  *
  * Revision 1.20  1998/05/18 13:07:02  adam
@@ -78,7 +87,6 @@
  * Revision 1.1  1995/11/01  11:56:06  quinn
  * Added Retrieval (data management) functions en masse.
  *
- *
  */
 
 #include <ctype.h>
@@ -89,8 +97,6 @@
 
 #include <oid.h>
 #include <log.h>
-#include <tpath.h>
-
 #include <data1.h>
 
 #define D1_MAX_NESTING  128
@@ -202,7 +208,7 @@ data1_attset *data1_attset_add (data1_handle dh, const char *name)
 	    *cp = '\0';
     }
     if (!attset)
-	logf (LOG_WARN|LOG_ERRNO, "couldn't load attribute set %s", name);
+	logf (LOG_WARN|LOG_ERRNO, "Couldn't load attribute set %s", name);
     else
     {
 	data1_attset_cache p = (data1_attset_cache)
@@ -296,7 +302,6 @@ void fix_element_ref (data1_handle dh, data1_absyn *absyn, data1_element *e)
 
 data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 {
-    char line[512], *r, cmd[512], args[512];
     data1_sub_elements *cur_elements = NULL;
     data1_absyn *res = 0;
     FILE *f;
@@ -305,19 +310,28 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
     data1_maptab **maptabp;
     data1_marctab **marcp;
     data1_termlist *all = 0;
+    data1_attset_child **attset_childp;
+    data1_tagset **tagset_childp;
     int level = 0;
+    int lineno = 0;
+    int argc;
+    char *argv[50], line[512];
 
     if (!(f = yaz_path_fopen(data1_get_tabpath (dh), file, "r")))
     {
 	logf(LOG_WARN|LOG_ERRNO, "Couldn't open %s", file);
 	return 0;
     }
-
-    res = (data1_absyn *)nmem_malloc(data1_nmem_get(dh), sizeof(*res));
+    
+    res = (data1_absyn *) nmem_malloc(data1_nmem_get(dh), sizeof(*res));
     res->name = 0;
     res->reference = VAL_NONE;
     res->tagset = 0;
-    res->attset = 0;
+    tagset_childp = &res->tagset;
+
+    res->attset = data1_empty_attset (dh);
+    attset_childp =  &res->attset->children;
+
     res->varset = 0;
     res->esetnames = 0;
     esetpp = &res->esetnames;
@@ -329,46 +343,38 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
     res->sub_elements = NULL;
     res->main_elements = NULL;
 
-    for (;;)
+    while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
     {
-	while ((r = fgets(line, 512, f)))
-	{
-	    while (*r && isspace(*r))
-		r++;
-	    if (*r && *r != '#')
-		break;
-	}
-	if (!r)
-            break;
-	if (sscanf(r, "%s %[^\n]", cmd, args) < 2)
-	    *args = '\0';
+	char *cmd = *argv;
 	if (!strcmp(cmd, "elm"))
 	{
 	    data1_element *new_element;
 	    int i;
-	    char path[512], name[512], termlists[512], *p, *sub_p;
+	    char *p, *sub_p, *path, *name, *termlists;
 	    int type, value;
 	    data1_termlist **tp;
 
+	    if (argc < 4)
+	    {
+		logf(LOG_WARN, "%s:%d: Bad # of args to elm", file, lineno);
+		continue;
+	    }
+	    path = argv[1];
+	    name = argv[2];
+	    termlists = argv[3];
+
 	    if (!cur_elements)
 	    {
-                cur_elements = (data1_sub_elements *)nmem_malloc(data1_nmem_get(dh),
-				    	   sizeof(*cur_elements));
+                cur_elements = (data1_sub_elements *)
+		    nmem_malloc(data1_nmem_get(dh), sizeof(*cur_elements));
 	        cur_elements->next = res->sub_elements;
 		cur_elements->elements = NULL;
 		cur_elements->name = "main";
 		res->sub_elements = cur_elements;
-
+		
 		level = 0;
     		ppl[level] = &cur_elements->elements;
             }
-	    if (sscanf(args, "%511s %511s %511s", path, name, termlists) < 3)
-	    {
-		logf(LOG_WARN, "Bad # of args to elm in %s: '%s'", 
-		    file, args);
-		fclose(f);
-		return 0;
-	    }
 	    p = path;
 	    for (i = 0;; i++)
 	    {
@@ -381,22 +387,22 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 	    }
 	    if (i > level + 1)
 	    {
-		logf(LOG_WARN, "Bad level inc in %s in '%s'", file, args);
+		logf(LOG_WARN, "%s:%d: Bad level increase", file, lineno);
 		fclose(f);
 		return 0;
 	    }
 	    level = i;
-	    new_element = *ppl[level] =
-		(data1_element *)nmem_malloc(data1_nmem_get(dh), sizeof(*new_element));
+	    new_element = *ppl[level] = (data1_element *)
+		nmem_malloc(data1_nmem_get(dh), sizeof(*new_element));
 	    new_element->next = new_element->children = 0;
 	    new_element->tag = 0;
 	    new_element->termlists = 0;
 	    new_element->sub_name = 0;
-
+	    
 	    tp = &new_element->termlists;
 	    ppl[level] = &new_element->next;
 	    ppl[level+1] = &new_element->children;
-
+	    
 	    /* consider subtree (if any) ... */
 	    if ((sub_p = strchr (p, ':')) && sub_p[1])
 	    {
@@ -409,15 +415,15 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 	    {
 		if (!res->tagset)
 		{
-		    logf(LOG_WARN, "No tagset loaded in %s", file);
+		    logf(LOG_WARN, "%s:%d: No tagset loaded", file, lineno);
 		    fclose(f);
 		    return 0;
 		}
 		if (!(new_element->tag = data1_gettagbynum (dh, res->tagset,
 							    type, value)))
 		{
-		    logf(LOG_WARN, "Couldn't find tag %s in tagset in %s",
-			p, file);
+		    logf(LOG_WARN, "%s:%d: Couldn't find tag %s in tagset",
+			 file, lineno, p);
 		    fclose(f);
 		    return 0;
 		}
@@ -426,12 +432,14 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 	    else if (*p)
 	    {
 		data1_tag *nt =
-		    new_element->tag = (data1_tag *)nmem_malloc(data1_nmem_get (dh),
-						   sizeof(*new_element->tag));
+		    new_element->tag = (data1_tag *)
+		    nmem_malloc(data1_nmem_get (dh),
+				sizeof(*new_element->tag));
 		nt->which = DATA1T_string;
 		nt->value.string = nmem_strdup(data1_nmem_get (dh), p);
-		nt->names = (data1_name *)nmem_malloc(data1_nmem_get(dh), 
-					sizeof(*new_element->tag->names));
+		nt->names = (data1_name *)
+		    nmem_malloc(data1_nmem_get(dh), 
+				sizeof(*new_element->tag->names));
 		nt->names->name = nt->value.string;
 		nt->names->next = 0;
 		nt->kind = DATA1K_string;
@@ -440,7 +448,7 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 	    }
 	    else
 	    {
-		logf(LOG_WARN, "Bad element is %s", file);
+		logf(LOG_WARN, "%s:%d: Bad element", file, lineno);
 		fclose(f);
 		return 0;
 	    }
@@ -450,34 +458,32 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 		new_element->termlists = 0;
 	    else
 	    {
-		if (!res->attset)
-		{
-		    logf(LOG_WARN, "No attset loaded in %s", file);
-		    fclose(f);
-		    return 0;
-		}
+		assert (res->attset);
 		do
 		{
 		    char attname[512], structure[512];
 		    int r;
-
+		    
 		    if (!(r = sscanf(p, "%511[^:,]:%511[^,]", attname,
-			structure)))
+				     structure)))
 		    {
-			logf(LOG_WARN, "Syntax error in termlistspec in %s",
-			    file);
+			logf(LOG_WARN,
+			     "%s:%d: Syntax error in termlistspec '%s'",
+			     file, lineno, p);
 			fclose(f);
 			return 0;
 		    }
 		    if (*attname == '!')
 			strcpy(attname, name);
-		    *tp = (data1_termlist *)nmem_malloc(data1_nmem_get(dh), sizeof(**tp));
+		    *tp = (data1_termlist *)
+			nmem_malloc(data1_nmem_get(dh), sizeof(**tp));
 		    (*tp)->next = 0;
 		    if (!((*tp)->att = data1_getattbyname(dh, res->attset,
 							  attname)))
 		    {
-			logf(LOG_WARN, "Couldn't find att '%s' in attset",
-			     attname);
+			logf(LOG_WARN,
+			     "%s:%d: Couldn't find att '%s' in attset",
+			     file, lineno, attname);
 			fclose(f);
 			return 0;
 		    }
@@ -485,8 +491,9 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 			(*tp)->structure = "w";
 		    else 
 		    {
-			(*tp)->structure = (char *)nmem_malloc (data1_nmem_get (dh),
-							strlen(structure)+1);
+			(*tp)->structure = (char *)
+			    nmem_malloc (data1_nmem_get (dh),
+					 strlen(structure)+1);
 			strcpy ((*tp)->structure, structure);
 		    }
 		    tp = &(*tp)->next;
@@ -498,20 +505,23 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 	}
  	else if (!strcmp(cmd, "section"))
 	{
-	    char name[512];
-	    if (sscanf(args, "%511s", name) < 1)
+	    char *name;
+	    
+	    if (argc < 2)
 	    {
-		logf(LOG_WARN, "Bad # of args to sub in %s: '%s'",
-                                file, args);
+		logf(LOG_WARN, "%s:%d: Bad # of args to section",
+		     file, lineno);
 		continue;
 	    }
-            cur_elements = (data1_sub_elements *)nmem_malloc(data1_nmem_get(dh),
-				    	   sizeof(*cur_elements));
+	    name = argv[1];
+	    
+            cur_elements = (data1_sub_elements *)
+		nmem_malloc(data1_nmem_get(dh), sizeof(*cur_elements));
 	    cur_elements->next = res->sub_elements;
 	    cur_elements->elements = NULL;
 	    cur_elements->name = nmem_strdup (data1_nmem_get(dh), name);
 	    res->sub_elements = cur_elements;
-
+	    
 	    level = 0;
     	    ppl[level] = &cur_elements->elements;
 	}
@@ -519,40 +529,42 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 	{
 	    char *p;
 	    data1_termlist **tp = &all;
-
+	    
 	    if (all)
 	    {
-		logf(LOG_WARN, "Too many ALL declarations in %s - ignored",
-		    file);
+		logf(LOG_WARN, "%s:%d: Too many 'all' directives - ignored",
+		     file, lineno);
 		continue;
 	    }
 
-	    p = args;
-	    if (!res->attset)
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "No attset loaded in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to 'all' directive",
+		     file, lineno);
+		continue;
 	    }
+	    p = argv[1];
+	    assert (res->attset);
 	    do
 	    {
 		char attname[512], structure[512];
 		int r;
-
+		
 		if (!(r = sscanf(p, "%511[^:,]:%511[^,]", attname,
-		    structure)))
+				 structure)))
 		{
-		    logf(LOG_WARN, "Syntax error in termlistspec in %s",
-			file);
+		    logf(LOG_WARN, "%s:%d: Syntax error in termlistspec",
+			 file, lineno);
 		    fclose(f);
 		    return 0;
 		}
-		*tp = (data1_termlist *)nmem_malloc(data1_nmem_get(dh), sizeof(**tp));
-		if (!((*tp)->att = data1_getattbyname (dh, res->attset,
-						       attname)))
+		*tp = (data1_termlist *)
+		    nmem_malloc(data1_nmem_get(dh), sizeof(**tp));
+		if (!((*tp)->att =
+		      data1_getattbyname (dh, res->attset, attname)))
 		{
-		    logf(LOG_WARN, "Couldn't find att '%s' in attset",
-			 attname);
+		    logf(LOG_WARN, "%s:%d: Couldn't find att '%s' in attset",
+			 file, lineno, attname);
 		    fclose(f);
 		    return 0;
 		}
@@ -560,8 +572,9 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 		    (*tp)->structure = "w";
 		else 
 		{
-		    (*tp)->structure = (char *)nmem_malloc (data1_nmem_get (dh),
-						    strlen(structure)+1);
+		    (*tp)->structure =
+			(char *)nmem_malloc (data1_nmem_get (dh),
+					     strlen(structure)+1);
 		    strcpy ((*tp)->structure, structure);
 		}
 		(*tp)->next = 0;
@@ -571,149 +584,161 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 	}
 	else if (!strcmp(cmd, "name"))
 	{
-	    char name[512];
-
-	    if (!sscanf(args, "%511s", name))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "Malformed name directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to name directive",
+		     file, lineno);
+		continue;
 	    }
-	    res->name = nmem_strdup(data1_nmem_get(dh), name);
+	    res->name = nmem_strdup(data1_nmem_get(dh), argv[1]);
 	}
 	else if (!strcmp(cmd, "reference"))
 	{
-	    char name[512];
-
-	    if (!sscanf(args, "%s", name))
+	    char *name;
+	    
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "Malformed reference in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to reference",
+		     file, lineno);
+		continue;
 	    }
+	    name = argv[1];
 	    if ((res->reference = oid_getvalbyname(name)) == VAL_NONE)
 	    {
-		logf(LOG_WARN, "Unknown tagset ref '%s' in %s", name, file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Unknown tagset ref '%s'", 
+		     file, lineno, name);
+		continue;
 	    }
 	}
 	else if (!strcmp(cmd, "attset"))
 	{
-	    char name[512];
-
-	    if (!sscanf(args, "%s", name))
+	    char *name;
+	    data1_attset *attset;
+	    
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "Malformed attset directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to attset",
+		     file, lineno);
+		continue;
 	    }
-	    if (!(res->attset = data1_get_attset (dh, name)))
+	    name = argv[1];
+	    if (!(attset = data1_get_attset (dh, name)))
 	    {
-		logf(LOG_WARN, "Attset failed in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Couldn't find attset  %s",
+		     file, lineno, name);
+		continue;
 	    }
+	    *attset_childp = (data1_attset_child *)
+		nmem_malloc (data1_nmem_get(dh), sizeof(**attset_childp));
+	    (*attset_childp)->child = attset;
+	    (*attset_childp)->next = 0;
+	    attset_childp = &(*attset_childp)->next;
 	}
 	else if (!strcmp(cmd, "tagset"))
 	{
-	    char name[512];
-
-	    if (!sscanf(args, "%s", name))
+	    char *name;
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "Malformed tagset directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to tagset",
+		     file, lineno);
+		continue;
 	    }
-	    if (!(res->tagset = data1_read_tagset (dh, name)))
+	    name = argv[1];
+	    if (!(*tagset_childp = data1_read_tagset (dh, name)))
 	    {
-		logf(LOG_WARN, "Tagset failed in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Couldn't load tagset %s",
+		     file, lineno, name);
+		continue;
 	    }
+	    tagset_childp = &(*tagset_childp)->next;
 	}
 	else if (!strcmp(cmd, "varset"))
 	{
-	    char name[512];
+	    char *name;
 
-	    if (!sscanf(args, "%s", name))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "Malformed varset directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args in varset",
+		     file, lineno);
+		continue;
 	    }
+	    name = argv[1];
 	    if (!(res->varset = data1_read_varset (dh, name)))
 	    {
-		logf(LOG_WARN, "Varset failed in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Couldn't load Varset %s",
+		     file, lineno, name);
+		continue;
 	    }
 	}
 	else if (!strcmp(cmd, "esetname"))
 	{
-	    char name[512], fname[512];
+	    char *name, *fname;
 
-	    if (sscanf(args, "%s %s", name, fname) != 2)
+	    if (argc != 3)
 	    {
-		logf(LOG_WARN, "Two arg's required for esetname in %s",
-                     file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args in esetname",
+		     file, lineno);
+		continue;
 	    }
-	    *esetpp = (data1_esetname *)nmem_malloc(data1_nmem_get(dh), sizeof(**esetpp));
+	    name = argv[1];
+	    fname = argv[2];
+	    
+	    *esetpp = (data1_esetname *)
+		nmem_malloc(data1_nmem_get(dh), sizeof(**esetpp));
 	    (*esetpp)->name = nmem_strdup(data1_nmem_get(dh), name);
 	    (*esetpp)->next = 0;
 	    if (*fname == '@')
 		(*esetpp)->spec = 0;
 	    else if (!((*esetpp)->spec = data1_read_espec1 (dh, fname)))
 	    {
-		logf(LOG_WARN, "%s: Espec-1 read failed", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Espec-1 read failed for %s",
+		     file, lineno, fname);
+		continue;
 	    }
 	    esetpp = &(*esetpp)->next;
 	}
 	else if (!strcmp(cmd, "maptab"))
 	{
-	    char name[512];
-
-	    if (sscanf(args, "%s", name) != 1)
+	    char *name;
+	    
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "One argument for maptab directive in %s",
-                     file);
+		logf(LOG_WARN, "%s:%d: Bad # of args for maptab",
+                     file, lineno);
 		continue;
 	    }
+	    name = argv[1];
 	    if (!(*maptabp = data1_read_maptab (dh, name)))
 	    {
-		logf(LOG_WARN, "Failed to read maptab %s in %s",
-                     name, file);
+		logf(LOG_WARN, "%s:%d: Couldn't load maptab %s",
+                     file, lineno, name);
 		continue;
 	    }
 	    maptabp = &(*maptabp)->next;
 	}
 	else if (!strcmp(cmd, "marc"))
 	{
-	    char name[512];
-
-	    if (sscanf(args, "%s", name) != 1)
+	    char *name;
+	    
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "One argument for marc directive in %s",
-		    file);
+		logf(LOG_WARN, "%s:%d: Bad # or args for marc",
+		     file, lineno);
 		continue;
 	    }
+	    name = argv[1];
 	    if (!(*marcp = data1_read_marctab (dh, name)))
 	    {
-		logf(LOG_WARN, "%Failed to read marctab %s in %s",
-                     name, file);
+		logf(LOG_WARN, "%s:%d: Couldn't read marctab %s",
+                     file, lineno, name);
 		continue;
 	    }
 	    marcp = &(*marcp)->next;
 	}
 	else
 	{
-	    logf(LOG_WARN, "Unknown directive '%s' in %s", cmd, file);
-	    fclose(f);
-	    return 0;
+	    logf(LOG_WARN, "%s:%d: Unknown directive '%s'", file, lineno, cmd);
+	    continue;
 	}
     }
     fclose(f);
@@ -725,6 +750,6 @@ data1_absyn *data1_read_absyn (data1_handle dh, const char *file)
 	    res->main_elements = cur_elements->elements;
 	fix_element_ref (dh, res, cur_elements->elements);
     }
-    logf (LOG_DEBUG, "end data1_read_absyn file=%s", file);
+    logf (LOG_DEBUG, "%s: data1_read_absyn end", file);
     return res;
 }
diff --git a/retrieval/d1_attset.c b/retrieval/d1_attset.c
index fde7272..7b580bc 100644
--- a/retrieval/d1_attset.c
+++ b/retrieval/d1_attset.c
@@ -4,7 +4,16 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: d1_attset.c,v $
- * Revision 1.9  1998-05-18 13:07:03  adam
+ * Revision 1.10  1998-10-13 16:09:48  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.9  1998/05/18 13:07:03  adam
  * Changed the way attribute sets are handled by the retriaval module.
  * Extended Explain conversion / schema.
  * Modified server and client to work with ASN.1 compiled protocol handlers.
@@ -44,7 +53,6 @@
 #include <log.h>
 #include <d1_attset.h>
 #include <data1.h>
-#include <tpath.h>
 
 data1_att *data1_getattbyname(data1_handle dh, data1_attset *s, char *name)
 {
@@ -65,68 +73,70 @@ data1_att *data1_getattbyname(data1_handle dh, data1_attset *s, char *name)
     return 0;
 }
 
+data1_attset *data1_empty_attset(data1_handle dh)
+{
+    NMEM mem = data1_nmem_get (dh);
+    data1_attset *res = (data1_attset*) nmem_malloc(mem,sizeof(*res));
+
+    res->name = 0;
+    res->reference = VAL_NONE;
+    res->atts = 0;
+    res->children = 0;
+    res->next = 0;
+    return res;
+}
+
 data1_attset *data1_read_attset(data1_handle dh, const char *file)
 {
-    char line[512], *r, cmd[512], args[512];
     data1_attset *res = 0;
     data1_attset_child **childp;
     data1_att **attp;
     FILE *f;
     NMEM mem = data1_nmem_get (dh);
+    int lineno = 0;
+    int argc;
+    char *argv[50], line[512];
 
     if (!(f = yaz_path_fopen(data1_get_tabpath(dh), file, "r")))
 	return NULL;
-    res = (data1_attset *)nmem_malloc(mem, sizeof(*res));
-    res->name = 0;
-    res->reference = VAL_NONE;
-    res->atts = 0;
-    res->children = 0;
+    res = data1_empty_attset (dh);
+
     childp = &res->children;
     attp = &res->atts;
 
-    for (;;)
+    while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
     {
-	while ((r = fgets(line, 512, f)))
-	{
-	    while (*r && isspace(*r))
-		r++;
-	    if (*r && *r != '#')
-		break;
-	}
-	if (!r)
-	{
-	    fclose(f);
-	    return res;
-	}
-	if (sscanf(r, "%s %[^\n]", cmd, args) < 2)
-	    *args = '\0';
+	char *cmd = argv[0];
 	if (!strcmp(cmd, "att"))
 	{
-	    int num, rr;
-	    char name[512], localstr[512];
+	    int num;
+	    char *name;
 	    data1_att *t;
 	    data1_local_attribute *locals;
-
-	    if ((rr = sscanf(args, "%511d %s %511s", &num, name, localstr)) < 2)
+	    
+	    if (argc < 3)
 	    {
-		logf(LOG_WARN, "Not enough arguments to att in '%s' in %s",
-		    args, file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to att", file, lineno);
+		continue;
 	    }
-	    if (rr < 3) /* no local attributes given */
+	    num = atoi (argv[1]);
+	    name = argv[2];
+	    
+	    if (argc == 3) /* no local attributes given */
 	    {
-		locals = (data1_local_attribute *)nmem_malloc(mem, sizeof(*locals));
+		locals = (data1_local_attribute *)
+		    nmem_malloc(mem, sizeof(*locals));
 		locals->local = num;
 		locals->next = 0;
 	    }
 	    else /* parse the string "local{,local}" */
 	    {
-		char *p = localstr;
+		char *p = argv[4];
 		data1_local_attribute **ap = &locals;
 		do
 		{
-		    *ap = (data1_local_attribute *)nmem_malloc(mem, sizeof(**ap));
+		    *ap = (data1_local_attribute *)
+			nmem_malloc(mem, sizeof(**ap));
 		    (*ap)->local = atoi(p);
 		    (*ap)->next = 0;
 		    ap = &(*ap)->next;
@@ -143,68 +153,68 @@ data1_attset *data1_read_attset(data1_handle dh, const char *file)
 	}
 	else if (!strcmp(cmd, "name"))
 	{
-	    char name[512];
-
-	    if (!sscanf(args, "%s", name))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s malformed name directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to name", file, lineno);
+		continue;
 	    }
 	}
 	else if (!strcmp(cmd, "reference"))
 	{
-	    char name[512];
+	    char *name;
 
-	    if (!sscanf(args, "%s", name))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s malformed reference directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to reference",
+		     file, lineno);
+		continue;
 	    }
+	    name = argv[1];
 	    if ((res->reference = oid_getvalbyname(name)) == VAL_NONE)
 	    {
-		logf(LOG_WARN, "Unknown attset name '%s' in %s", name, file);
+		logf(LOG_WARN, "%s:%d: Unknown reference oid '%s'",
+		     file, lineno, name);
 		fclose(f);
 		return 0;
 	    }
 	}
 	else if (!strcmp(cmd, "ordinal"))
 	{
-	    int dummy;
-	    if (!sscanf(args, "%d", &dummy))
-	    {
-		logf(LOG_WARN, "%s malformed ordinal directive in %s", file);
-		fclose(f);
-		return 0;
-	    }
+	    logf (LOG_WARN, "%s:%d: Directive ordinal ignored",
+		  file, lineno);
 	}
 	else if (!strcmp(cmd, "include"))
 	{
-	    char name[512];
+	    char *name;
+	    data1_attset *attset;
 
-	    if (!sscanf(args, "%s", name))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s malformed reference directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # of args to include",
+		     file, lineno);
+		continue;
 	    }
-	    *childp = (data1_attset_child *)
-		nmem_malloc (mem, sizeof(**childp));
-	    if (!((*childp)->child = data1_get_attset (dh, name)))
+	    name = argv[1];
+
+	    if (!(attset = data1_get_attset (dh, name)))
 	    {
-		logf(LOG_WARN, "Inclusion failed in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Include of attset %s failed",
+		     file, lineno, name);
+		continue;
+		
 	    }
+	    *childp = (data1_attset_child *)
+		nmem_malloc (mem, sizeof(**childp));
+	    (*childp)->child = attset;
 	    (*childp)->next = 0;
 	    childp = &(*childp)->next;
 	}
 	else
 	{
-	    logf(LOG_WARN, "Unknown directive '%s' in %s", cmd, file);
-	    fclose(f);
-	    return 0;
+	    logf(LOG_WARN, "%s:%d: Unknown directive '%s'",
+		 file, lineno, cmd);
 	}
     }
+    fclose(f);
+    return res;
 }
diff --git a/retrieval/d1_espec.c b/retrieval/d1_espec.c
index 932ee64..4bbd373 100644
--- a/retrieval/d1_espec.c
+++ b/retrieval/d1_espec.c
@@ -1,10 +1,19 @@
 /*
- * Copyright (c) 1995-1997, Index Data.
+ * Copyright (c) 1995-1998, Index Data.
  * See the file LICENSE for details.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: d1_espec.c,v $
- * Revision 1.14  1998-02-11 11:53:35  adam
+ * Revision 1.15  1998-10-13 16:09:49  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.14  1998/02/11 11:53:35  adam
  * Changed code so that it compiles as C++.
  *
  * Revision 1.13  1997/11/24 11:33:56  adam
@@ -61,11 +70,10 @@
 #include <odr.h>
 #include <proto.h>
 #include <log.h>
-#include <readconf.h>
-#include <tpath.h>
 #include <data1.h>
 
-static Z_Variant *read_variant(int argc, char **argv, NMEM nmem)
+static Z_Variant *read_variant(int argc, char **argv, NMEM nmem,
+			       const char *file, int lineno)
 {
     Z_Variant *r = (Z_Variant *)nmem_malloc(nmem, sizeof(*r));
     oident var1;
@@ -90,8 +98,8 @@ static Z_Variant *read_variant(int argc, char **argv, NMEM nmem)
 
 	if (sscanf(argv[i], "(%d,%d,%[^)])", &zclass, &type, value) < 3)
 	{
-	    logf(LOG_WARN, "Syntax error in variant component '%s'",
-	    	argv[i]);
+	    logf(LOG_WARN, "%s:%d: Syntax error in variant component '%s'",
+		 file, lineno, argv[i]);
 	    return 0;
 	}
 	t = r->triples[i] = (Z_Triple *)nmem_malloc(nmem, sizeof(Z_Triple));
@@ -112,28 +120,32 @@ static Z_Variant *read_variant(int argc, char **argv, NMEM nmem)
 	else if (isdigit(*value))
 	{
 	    t->which = Z_Triple_integer;
-	    t->value.integer = (int *)nmem_malloc(nmem, sizeof(*t->value.integer));
+	    t->value.integer = (int *)
+		nmem_malloc(nmem, sizeof(*t->value.integer));
 	    *t->value.integer = atoi(value);
 	}
 	else
 	{
 	    t->which = Z_Triple_internationalString;
-	    t->value.internationalString = (char *)nmem_malloc(nmem, strlen(value)+1);
+	    t->value.internationalString = (char *)
+		nmem_malloc(nmem, strlen(value)+1);
 	    strcpy(t->value.internationalString, value);
 	}
     }
     return r;
 }
 
-static Z_Occurrences *read_occurrences(char *occ, NMEM nmem)
+static Z_Occurrences *read_occurrences(char *occ, NMEM nmem,
+				       const char *file, int lineno)
 {
     Z_Occurrences *op = (Z_Occurrences *)nmem_malloc(nmem, sizeof(*op));
     char *p;
-
+    
     if (!occ)
     {
 	op->which = Z_Occurrences_values;
-	op->u.values = (Z_OccurValues *)nmem_malloc(nmem, sizeof(Z_OccurValues));
+	op->u.values = (Z_OccurValues *)
+	    nmem_malloc(nmem, sizeof(Z_OccurValues));
 	op->u.values->start = (int *)nmem_malloc(nmem, sizeof(int));
 	*op->u.values->start = 1;
 	op->u.values->howMany = 0;
@@ -151,10 +163,11 @@ static Z_Occurrences *read_occurrences(char *occ, NMEM nmem)
     else
     {
 	Z_OccurValues *ov = (Z_OccurValues *)nmem_malloc(nmem, sizeof(*ov));
-
+    
 	if (!isdigit(*occ))
 	{
-	    logf(LOG_WARN, "Bad occurrences-spec in %s", occ);
+	    logf(LOG_WARN, "%s:%d: Bad occurrences-spec %s",
+		 file, lineno, occ);
 	    return 0;
 	}
 	op->which = Z_Occurrences_values;
@@ -173,13 +186,14 @@ static Z_Occurrences *read_occurrences(char *occ, NMEM nmem)
 }
 
 
-static Z_ETagUnit *read_tagunit(char *buf, NMEM nmem)
+static Z_ETagUnit *read_tagunit(char *buf, NMEM nmem,
+				const char *file, int lineno)
 {
     Z_ETagUnit *u = (Z_ETagUnit *)nmem_malloc(nmem, sizeof(*u));
     int terms;
     int type;
     char value[512], occ[512];
-
+    
     if (*buf == '*')
     {
 	u->which = Z_ETagUnit_wildPath;
@@ -189,18 +203,18 @@ static Z_ETagUnit *read_tagunit(char *buf, NMEM nmem)
     {
 	u->which = Z_ETagUnit_wildThing;
 	if (buf[1] == ':')
-	    u->u.wildThing = read_occurrences(buf+2, nmem);
+	    u->u.wildThing = read_occurrences(buf+2, nmem, file, lineno);
 	else
-	    u->u.wildThing = read_occurrences(0, nmem);
+	    u->u.wildThing = read_occurrences(0, nmem, file, lineno);
     }
     else if ((terms = sscanf(buf, "(%d,%[^)]):%[a-z0-9+]", &type, value,
-	occ)) >= 2)
+			     occ)) >= 2)
     {
 	int numval;
 	Z_SpecificTag *t;
 	char *valp = value;
 	int force_string = 0;
-
+	
 	if (*valp == '\'')
 	{
 	    valp++;
@@ -210,7 +224,8 @@ static Z_ETagUnit *read_tagunit(char *buf, NMEM nmem)
 	u->u.specificTag = t = (Z_SpecificTag *)nmem_malloc(nmem, sizeof(*t));
 	t->tagType = (int *)nmem_malloc(nmem, sizeof(*t->tagType));
 	*t->tagType = type;
-	t->tagValue = (Z_StringOrNumeric *)nmem_malloc(nmem, sizeof(*t->tagValue));
+	t->tagValue = (Z_StringOrNumeric *)
+	    nmem_malloc(nmem, sizeof(*t->tagValue));
 	if (!force_string && (numval = atoi(valp)))
 	{
 	    t->tagValue->which = Z_StringOrNumeric_numeric;
@@ -224,7 +239,7 @@ static Z_ETagUnit *read_tagunit(char *buf, NMEM nmem)
 	    strcpy(t->tagValue->u.string, valp);
 	}
 	if (terms > 2) /* an occurrences-spec exists */
-	    t->occurrences = read_occurrences(occ, nmem);
+	    t->occurrences = read_occurrences(occ, nmem, file, lineno);
 	else
 	    t->occurrences = 0;
     }
@@ -239,16 +254,17 @@ Z_Espec1 *data1_read_espec1 (data1_handle dh, const char *file)
 {
     FILE *f;
     NMEM nmem = data1_nmem_get (dh);
+    int lineno = 0;
     int argc, size_esn = 0;
     char *argv[50], line[512];
     Z_Espec1 *res = (Z_Espec1 *)nmem_malloc(nmem, sizeof(*res));
-
+    
     if (!(f = yaz_path_fopen(data1_get_tabpath(dh), file, "r")))
     {
 	logf(LOG_WARN|LOG_ERRNO, "%s", file);
 	return 0;
     }
-
+    
     res->num_elementSetNames = 0;
     res->elementSetNames = 0;
     res->defaultVariantSetId = 0;
@@ -256,34 +272,42 @@ Z_Espec1 *data1_read_espec1 (data1_handle dh, const char *file)
     res->defaultTagType = 0;
     res->num_elements = 0;
     res->elements = 0;
-
-    while ((argc = readconf_line(f, line, 512, argv, 50)))
+    
+    while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
 	if (!strcmp(argv[0], "elementsetnames"))
 	{
 	    int nnames = argc-1, i;
-
+	    
 	    if (!nnames)
 	    {
-		logf(LOG_WARN, "%s: Empty elementsetnames directive",
-		    file);
+		logf(LOG_WARN, "%s:%d: Empty elementsetnames directive",
+		     file, lineno);
 		continue;
 	    }
-
-	    res->elementSetNames = (char **)nmem_malloc(nmem, sizeof(char**)*nnames);
+	    
+	    res->elementSetNames =
+		(char **)nmem_malloc(nmem, sizeof(char**)*nnames);
 	    for (i = 0; i < nnames; i++)
 	    {
-		res->elementSetNames[i] = (char *)nmem_malloc(nmem,
-                                                      strlen(argv[i+1])+1);
+		res->elementSetNames[i] = (char *)
+		    nmem_malloc(nmem, strlen(argv[i+1])+1);
 		strcpy(res->elementSetNames[i], argv[i+1]);
 	    }
 	    res->num_elementSetNames = nnames;
 	}
 	else if (!strcmp(argv[0], "defaultvariantsetid"))
 	{
-	    if (argc != 2 || !(res->defaultVariantSetId =
-		odr_getoidbystr_nmem(nmem, argv[1])))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad defaultvariantsetid directive", file);
+		logf(LOG_WARN, "%s:%d: Bad # of args for %s",
+		     file, lineno, argv[0]);
+		continue;
+	    }
+	    if (!(res->defaultVariantSetId =
+		  odr_getoidbystr_nmem(nmem, argv[1])))
+	    {
+		logf(LOG_WARN, "%s:%d: Bad defaultvariantsetid",
+		     file, lineno);
 		continue;
 	    }
 	}
@@ -291,7 +315,8 @@ Z_Espec1 *data1_read_espec1 (data1_handle dh, const char *file)
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad defaulttagtype directive", file);
+		logf(LOG_WARN, "%s:%d: Bad # of args for %s",
+		     file, lineno, argv[0]);
 		continue;
 	    }
 	    res->defaultTagType = (int *)nmem_malloc(nmem, sizeof(int));
@@ -299,10 +324,11 @@ Z_Espec1 *data1_read_espec1 (data1_handle dh, const char *file)
 	}
 	else if (!strcmp(argv[0], "defaultvariantrequest"))
 	{
-	    if (!(res->defaultVariantRequest = read_variant(argc-1,
-                                                            argv+1, nmem)))
+	    if (!(res->defaultVariantRequest =
+		  read_variant(argc-1, argv+1, nmem, file, lineno)))
 	    {
-		logf(LOG_WARN, "%s: Bad defaultvariantrequest", file);
+		logf(LOG_WARN, "%s:%d: Bad defaultvariantrequest",
+		     file, lineno);
 		continue;
 	    }
 	}
@@ -316,24 +342,28 @@ Z_Espec1 *data1_read_espec1 (data1_handle dh, const char *file)
 	    int num, i = 0;
 	    
 	    if (!res->elements)
-		res->elements = (Z_ElementRequest **)nmem_malloc(nmem, size_esn = 24*sizeof(er));
+		res->elements = (Z_ElementRequest **)
+		    nmem_malloc(nmem, size_esn = 24*sizeof(er));
 	    else if (res->num_elements >= (int) (size_esn/sizeof(er)))
 	    {
 		Z_ElementRequest **oe = res->elements;
 		size_esn *= 2;
-		res->elements = (Z_ElementRequest **)nmem_malloc (nmem, size_esn*sizeof(er));
+		res->elements = (Z_ElementRequest **)
+		    nmem_malloc (nmem, size_esn*sizeof(er));
 		memcpy (res->elements, oe, size_esn/2);
 	    }
 	    if (argc < 2)
 	    {
-		logf(LOG_WARN, "%s: Empty simpleelement directive", file);
+		logf(LOG_WARN, "%s:%d: Bad # of args for %s",
+		     file, lineno, argv[0]);
 		continue;
 	    }
 	    
 	    res->elements[res->num_elements++] = er =
 		(Z_ElementRequest *)nmem_malloc(nmem, sizeof(*er));
 	    er->which = Z_ERequest_simpleElement;
-	    er->u.simpleElement = se = (Z_SimpleElement *)nmem_malloc(nmem, sizeof(*se));
+	    er->u.simpleElement = se = (Z_SimpleElement *)
+		nmem_malloc(nmem, sizeof(*se));
 	    se->variantRequest = 0;
 	    se->path = tp = (Z_ETagPath *)nmem_malloc(nmem, sizeof(*tp));
 	    tp->num_tags = 0;
@@ -342,7 +372,8 @@ Z_Espec1 *data1_read_espec1 (data1_handle dh, const char *file)
 	     */
 	    for (num = 1, ep = path; (ep = strchr(ep, '/')); num++, ep++)
 		;
-	    tp->tags = (Z_ETagUnit **)nmem_malloc(nmem, sizeof(Z_ETagUnit*)*num);
+	    tp->tags = (Z_ETagUnit **)
+		nmem_malloc(nmem, sizeof(Z_ETagUnit*)*num);
 	    
 	    for ((ep = strchr(path, '/')) ; path ;
 		 (void)((path = ep) && (ep = strchr(path, '/'))))
@@ -351,18 +382,17 @@ Z_Espec1 *data1_read_espec1 (data1_handle dh, const char *file)
 		    ep++;
 		
 		assert(i<num);
-		tp->tags[tp->num_tags++] = read_tagunit(path, nmem);
+		tp->tags[tp->num_tags++] =
+		    read_tagunit(path, nmem, file, lineno);
 	    }
 	    
 	    if (argc > 2 && !strcmp(argv[2], "variant"))
-		se->variantRequest= read_variant(argc-3, argv+3, nmem);
+		se->variantRequest=
+		    read_variant(argc-3, argv+3, nmem, file, lineno);
 	}
 	else
-	{
-	    logf(LOG_WARN, "%s: Unknown directive %s", file, argv[0]);
-	    fclose(f);
-	    return 0;
-	}
+	    logf(LOG_WARN, "%s:%d: Unknown directive '%s'",
+		 file, lineno, argv[0]);
     fclose (f);
     return res;
 }
diff --git a/retrieval/d1_map.c b/retrieval/d1_map.c
index 4c8c6a8..e1eaf85 100644
--- a/retrieval/d1_map.c
+++ b/retrieval/d1_map.c
@@ -4,7 +4,16 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: d1_map.c,v $
- * Revision 1.13  1998-02-11 11:53:35  adam
+ * Revision 1.14  1998-10-13 16:09:50  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.13  1998/02/11 11:53:35  adam
  * Changed code so that it compiles as C++.
  *
  * Revision 1.12  1997/11/18 09:51:09  adam
@@ -66,6 +75,7 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
     NMEM mem = data1_nmem_get (dh);
     data1_maptab *res = (data1_maptab *)nmem_malloc(mem, sizeof(*res));
     FILE *f;
+    int lineno = 0;
     int argc;
     char *argv[50], line[512];
     data1_mapunit **mapp;
@@ -78,23 +88,25 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
     }
 
     res->name = 0;
-    res->target_absyn_ref = ODR_NONE;
+    res->target_absyn_ref = VAL_NONE;
     res->map = 0;
     mapp = &res->map;
     res->next = 0;
 
-    while ((argc = readconf_line(f, line, 512, argv, 50)))
+    while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
 	if (!strcmp(argv[0], "targetref"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: one argument required for targetref",
-		    file);
+		logf(LOG_WARN, "%s:%d: Bad # args for targetref",
+		    file, lineno);
 		continue;
 	    }
-	    if ((res->target_absyn_ref = oid_getvalbyname(argv[1])) == ODR_NONE)
+	    if ((res->target_absyn_ref = oid_getvalbyname(argv[1]))
+		== VAL_NONE)
 	    {
-		logf(LOG_WARN, "%s: Unknown reference '%s'", file, argv[1]);
+		logf(LOG_WARN, "%s:%d: Unknown reference '%s'",
+		     file, lineno, argv[1]);
 		continue;
 	    }
 	}
@@ -102,11 +114,12 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: one argument required for targetref",
-		    file);
+		logf(LOG_WARN, "%s:%d: Bad # args for targetname",
+		    file, lineno);
 		continue;
 	    }
-	    res->target_absyn_name = (char *)nmem_malloc(mem, strlen(argv[1])+1);
+	    res->target_absyn_name =
+		(char *)nmem_malloc(mem, strlen(argv[1])+1);
 	    strcpy(res->target_absyn_name, argv[1]);
 	}
 	else if (!yaz_matchstr(argv[0], "localnumeric"))
@@ -115,8 +128,7 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: one argument required for name",
-		    file);
+		logf(LOG_WARN, "%s:%d: Bad # args for name", file, lineno);
 		continue;
 	    }
 	    res->name = (char *)nmem_malloc(mem, strlen(argv[1])+1);
@@ -129,8 +141,8 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
 
 	    if (argc < 3)
 	    {
-		logf(LOG_WARN, "%s: At least 2 arguments required for map",
-		    file);
+		logf(LOG_WARN, "%s:%d: Bad # of args for map",
+		    file, lineno);
 		continue;
 	    }
 	    *mapp = (data1_mapunit *)nmem_malloc(mem, sizeof(**mapp));
@@ -139,7 +151,8 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
 		(*mapp)->no_data = 1;
 	    else
 		(*mapp)->no_data = 0;
-	    (*mapp)->source_element_name = (char *)nmem_malloc(mem, strlen(argv[1])+1);
+	    (*mapp)->source_element_name =
+		(char *)nmem_malloc(mem, strlen(argv[1])+1);
 	    strcpy((*mapp)->source_element_name, argv[1]);
 	    mtp = &(*mapp)->target_path;
 	    if (*path == '/')
@@ -155,8 +168,8 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
 		if ((np = sscanf(path, "(%d,%[^)]):%[^/]", &type, valstr,
 		    parm)) < 2)
 		{
-		    logf(LOG_WARN, "%s: Syntax error in map directive: %s",
-		        file, argv[2]);
+		    logf(LOG_WARN, "%s:%d: Syntax error in map directive: %s",
+		        file, lineno, argv[2]);
 		    fclose(f);
 		    return 0;
 		}
@@ -175,7 +188,8 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
 		else
 		{
 		    (*mtp)->which = D1_MAPTAG_string;
-		    (*mtp)->value.string = (char *)nmem_malloc(mem, strlen(valstr)+1);
+		    (*mtp)->value.string =
+			(char *)nmem_malloc(mem, strlen(valstr)+1);
 		    strcpy((*mtp)->value.string, valstr);
 		}
 		mtp = &(*mtp)->next;
@@ -183,7 +197,8 @@ data1_maptab *data1_read_maptab (data1_handle dh, const char *file)
 	    mapp = &(*mapp)->next;
 	}
 	else 
-	    logf(LOG_WARN, "%s: Unknown directive '%s'", argv[0]);
+	    logf(LOG_WARN, "%s:%d: Unknown directive '%s'",
+		 file, lineno, argv[0]);
 
     fclose(f);
     return res;
diff --git a/retrieval/d1_marc.c b/retrieval/d1_marc.c
index 198e852..0d257d6 100644
--- a/retrieval/d1_marc.c
+++ b/retrieval/d1_marc.c
@@ -4,7 +4,16 @@
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: d1_marc.c,v $
- * Revision 1.12  1998-02-23 10:57:09  adam
+ * Revision 1.13  1998-10-13 16:09:52  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.12  1998/02/23 10:57:09  adam
  * Take care of integer data nodes as well in conversion.
  *
  * Revision 1.11  1998/02/11 11:53:35  adam
@@ -63,6 +72,7 @@ data1_marctab *data1_read_marctab (data1_handle dh, const char *file)
     NMEM mem = data1_nmem_get (dh);
     data1_marctab *res = (data1_marctab *)nmem_malloc(mem, sizeof(*res));
     char line[512], *argv[50];
+    int lineno = 0;
     int argc;
     
     if (!(f = yaz_path_fopen(data1_get_tabpath(dh), file, "r")))
@@ -86,87 +96,96 @@ data1_marctab *data1_read_marctab (data1_handle dh, const char *file)
     res->force_indicator_length = -1;
     res->force_identifier_length = -1;
     strcpy(res->user_systems, "z  ");
-
-    while ((argc = readconf_line(f, line, 512, argv, 50)))
-	if (!strcmp(argv[0], "name"))
+    
+    while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
+	if (!strcmp(*argv, "name"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad name directive");
+		logf(LOG_WARN, "%s:%d:Missing arg for %s", file, lineno,
+		     *argv);
 		continue;
 	    }
 	    res->name = nmem_strdup(mem, argv[1]);
 	}
-	else if (!strcmp(argv[0], "reference"))
+	else if (!strcmp(*argv, "reference"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad name directive");
+		logf(LOG_WARN, "%s:%d: Missing arg for %s", file, lineno,
+		     *argv);
 		continue;
 	    }
 	    if ((res->reference = oid_getvalbyname(argv[1])) == VAL_NONE)
 	    {
-		logf(LOG_WARN, "%s: Unknown tagset ref '%s' in %s", file,
-		    argv[1]);
+		logf(LOG_WARN, "%s:%d: Unknown tagset reference '%s'",
+		     file, lineno, argv[1]);
 		continue;
 	    }
 	}
-	else if (!strcmp(argv[0], "length-data-entry"))
+	else if (!strcmp(*argv, "length-data-entry"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad data-length-entry");
+		logf(LOG_WARN, "%s:%d: Missing arg for %s", file, lineno,
+		     *argv);
 		continue;
 	    }
 	    res->length_data_entry = atoi(argv[1]);
 	}
-	else if (!strcmp(argv[0], "length-starting"))
+	else if (!strcmp(*argv, "length-starting"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad length-starting");
+		logf(LOG_WARN, "%s:%d: Missing arg for %s", file, lineno,
+		     *argv);
 		continue;
 	    }
 	    res->length_starting = atoi(argv[1]);
 	}
-	else if (!strcmp(argv[0], "length-implementation"))
+	else if (!strcmp(*argv, "length-implementation"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad length-implentation");
+		logf(LOG_WARN, "%s:%d: Missing arg for %s", file, lineno,
+		     *argv);
 		continue;
 	    }
 	    res->length_implementation = atoi(argv[1]);
 	}
-	else if (!strcmp(argv[0], "future-use"))
+	else if (!strcmp(*argv, "future-use"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad future-use");
+		logf(LOG_WARN, "%s:%d: Missing arg for %s", file, lineno,
+		     *argv);
 		continue;
 	    }
 	    strncpy(res->future_use, argv[1], 2);
 	}
-	else if (!strcmp(argv[0], "force-indicator-length"))
+	else if (!strcmp(*argv, "force-indicator-length"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad future-use");
+		logf(LOG_WARN, "%s:%d: Missing arg for %s", file, lineno,
+		     *argv);
 		continue;
 	    }
 	    res->force_indicator_length = atoi(argv[1]);
 	}
-	else if (!strcmp(argv[0], "force-identifier-length"))
+	else if (!strcmp(*argv, "force-identifier-length"))
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: Bad future-use");
+		logf(LOG_WARN, "%s:%d: Missing arg for %s", file, lineno,
+		     *argv);
 		continue;
 	    }
 	    res->force_identifier_length = atoi(argv[1]);
 	}
 	else
-	    logf(LOG_WARN, "%s: Bad directive '%s'", file, argv[0]);
+	    logf(LOG_WARN, "%s:%d: Unknown directive '%s'", file, lineno,
+		 *argv);
 
     fclose(f);
     return res;
diff --git a/retrieval/d1_tagset.c b/retrieval/d1_tagset.c
index 65311dd..38b785f 100644
--- a/retrieval/d1_tagset.c
+++ b/retrieval/d1_tagset.c
@@ -1,10 +1,19 @@
 /*
- * Copyright (c) 1995-1997, Index Data.
+ * Copyright (c) 1995-1998, Index Data.
  * See the file LICENSE for details.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: d1_tagset.c,v $
- * Revision 1.8  1998-05-18 13:07:07  adam
+ * Revision 1.9  1998-10-13 16:09:53  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.8  1998/05/18 13:07:07  adam
  * Changed the way attribute sets are handled by the retriaval module.
  * Extended Explain conversion / schema.
  * Modified server and client to work with ASN.1 compiled protocol handlers.
@@ -39,8 +48,6 @@
 #include <string.h>
 
 #include <log.h>
-#include <tpath.h>
-
 #include <data1.h>
 
 /*
@@ -118,59 +125,57 @@ data1_tag *data1_gettagbyname (data1_handle dh, data1_tagset *s, char *name)
     return 0;
 }
 
+data1_tagset *data1_empty_tagset (data1_handle dh)
+{
+    data1_tagset *res =
+	(data1_tagset *) nmem_malloc(data1_nmem_get (dh), sizeof(*res));
+    res->name = 0;
+    res->reference = VAL_NONE;
+    res->type = 0;
+    res->tags = 0;
+    res->children = 0;
+    res->next = 0;
+    return res;
+}
+
 data1_tagset *data1_read_tagset (data1_handle dh, char *file)
 {
     NMEM mem = data1_nmem_get (dh);
-    char line[512], *r, cmd[512], args[512];
     data1_tagset *res = 0, **childp;
     data1_tag **tagp;
     FILE *f;
+    int lineno = 0;
+    int argc;
+    char *argv[50], line[512];
 
     if (!(f = yaz_path_fopen(data1_get_tabpath(dh), file, "r")))
     {
 	logf(LOG_WARN|LOG_ERRNO, "%s", file);
 	return 0;
     }
-
-    res = (data1_tagset *)nmem_malloc(mem, sizeof(*res));
-    res->name = 0;
-    res->type = 0;
-    res->tags = 0;
-    res->children = 0;
-    res->next = 0;
+    res = data1_empty_tagset (dh);
     childp = &res->children;
     tagp = &res->tags;
 
-    for (;;)
+    while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
     {
-	while ((r = fgets(line, 512, f)))
-	{
-	    while (*r && isspace(*r))
-		r++;
-	    if (*r && *r != '#')
-		break;
-	}
-	if (!r)
-	{
-	    fclose(f);
-	    return res;
-	}
-	if (sscanf(r, "%s %[^\n]", cmd, args) < 2)
-	    *args = '\0';
+	char *cmd = *argv;
 	if (!strcmp(cmd, "tag"))
 	{
 	    int value;
-	    char names[512], type[512], *nm;
+	    char *names, *type, *nm;
 	    data1_tag *rr;
 	    data1_name **npp;
 
-	    if (sscanf(args, "%d %s %s", &value, names, type) < 3)
+	    if (argc != 4)
 	    {
-		logf(LOG_WARN, "Bad number of parms in '%s' in %s",
-		    args, file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # args to tag", file, lineno);
+		continue;
 	    }
+	    value = atoi(argv[1]);
+	    names = argv[2];
+	    type = argv[3];
+
 	    rr = *tagp = (data1_tag *)nmem_malloc(mem, sizeof(*rr));
 	    rr->tagset = res;
 	    rr->next = 0;
@@ -182,7 +187,8 @@ data1_tagset *data1_read_tagset (data1_handle dh, char *file)
 
 	    if (!(rr->kind = data1_maptype(dh, type)))
 	    {
-		logf(LOG_WARN, "Unknown datatype %s in %s", type, file);
+		logf(LOG_WARN, "%s:%d: Unknown datatype %s",
+		     file, lineno, type);
 		fclose(f);
 		return 0;
 	    }
@@ -207,65 +213,64 @@ data1_tagset *data1_read_tagset (data1_handle dh, char *file)
 	}
 	else if (!strcmp(cmd, "name"))
 	{
-	    char name[512];
-
-	    if (!sscanf(args, "%s", name))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s malformed name directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # args to name", file, lineno);
+		continue;
 	    }
-	    res->name = nmem_strdup(mem, args);
+	    res->name = nmem_strdup(mem, argv[1]);
 	}
 	else if (!strcmp(cmd, "reference"))
 	{
-	    char name[512];
-
-	    if (!sscanf(args, "%s", name))
+	    char *name;
+	    
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s malformed reference directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # args to reference", file, lineno);
+		continue;
 	    }
+	    name = argv[1];
 	    if ((res->reference = oid_getvalbyname(name)) == VAL_NONE)
 	    {
-		logf(LOG_WARN, "Unknown tagset ref '%s' in %s", name, file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Unknown tagset ref '%s'",
+		     file, lineno, name);
+		continue;
 	    }
 	}
 	else if (!strcmp(cmd, "type"))
 	{
-	    if (!sscanf(args, "%d", &res->type))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s malformed type directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # args to type", file, lineno);
+		continue;
 	    }
+	    res->type = atoi(argv[1]);
 	}
 	else if (!strcmp(cmd, "include"))
 	{
-	    char name[512];
+	    char *name;
 
-	    if (!sscanf(args, "%s", name))
+	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s malformed reference directive in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # args to include",
+		     file, lineno);
+		continue;
 	    }
+	    name = argv[1];
 	    if (!(*childp = data1_read_tagset (dh, name)))
 	    {
-		logf(LOG_WARN, "Inclusion failed in %s", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Inclusion failed for tagset %s",
+		     file, lineno, name);
+		continue;
 	    }
 	    childp = &(*childp)->next;
 	}
 	else
 	{
-	    logf(LOG_WARN, "Unknown directive '%s' in %s", cmd, file);
-	    fclose(f);
-	    return 0;
+	    logf(LOG_WARN, "%s:%d: Unknown directive '%s'",
+		 file, lineno, cmd);
 	}
     }
+    fclose(f);
+    return res;
 }
diff --git a/retrieval/d1_varset.c b/retrieval/d1_varset.c
index b43c069..adf3e2e 100644
--- a/retrieval/d1_varset.c
+++ b/retrieval/d1_varset.c
@@ -1,10 +1,19 @@
 /*
- * Copyright (c) 1995-1997, Index Data.
+ * Copyright (c) 1995-1998, Index Data.
  * See the file LICENSE for details.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: d1_varset.c,v $
- * Revision 1.7  1998-02-11 11:53:35  adam
+ * Revision 1.8  1998-10-13 16:09:54  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.7  1998/02/11 11:53:35  adam
  * Changed code so that it compiles as C++.
  *
  * Revision 1.6  1997/09/17 12:10:39  adam
@@ -31,11 +40,9 @@
 #include <string.h>
 #include <stdlib.h>
 
-#include <readconf.h>
 #include <oid.h>
 #include <log.h>
 
-#include <tpath.h>
 #include <data1.h>
 
 data1_vartype *data1_getvartypebyct (data1_handle dh, data1_varset *set,
@@ -50,7 +57,8 @@ data1_vartype *data1_getvartypebyct (data1_handle dh, data1_varset *set,
 	    for (t = c->types; t; t = t->next)
 		if (!data1_matchstr(t->name, type))
 		    return t;
-	    logf(LOG_WARN, "Unknown variant type %s in class %s", type, zclass);
+	    logf(LOG_WARN, "Unknown variant type %s in class %s",
+		 type, zclass);
 	    return 0;
 	}
     logf(LOG_WARN, "Unknown variant class %s", zclass);
@@ -64,6 +72,7 @@ data1_varset *data1_read_varset (data1_handle dh, const char *file)
     data1_varclass **classp = &res->classes, *zclass = 0;
     data1_vartype **typep = 0;
     FILE *f;
+    int lineno = 0;
     int argc;
     char *argv[50],line[512];
 
@@ -76,18 +85,19 @@ data1_varset *data1_read_varset (data1_handle dh, const char *file)
 	logf(LOG_WARN|LOG_ERRNO, "%s", file);
 	return 0;
     }
-    while ((argc = readconf_line(f, line, 512, argv, 50)))
+    while ((argc = readconf_line(f, &lineno, line, 512, argv, 50)))
 	if (!strcmp(argv[0], "class"))
 	{
 	    data1_varclass *r;
-
+	    
 	    if (argc != 3)
 	    {
-		logf(LOG_FATAL, "%s: malformed class directive", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # or args to class",
+		     file, lineno);
+		continue;
 	    }
-	    *classp = r = zclass = (data1_varclass *)nmem_malloc(mem, sizeof(*r));
+	    *classp = r = zclass = (data1_varclass *)
+		nmem_malloc(mem, sizeof(*r));
 	    r->set = res;
 	    r->zclass = atoi(argv[1]);
 	    r->name = nmem_strdup(mem, argv[2]);
@@ -102,15 +112,14 @@ data1_varset *data1_read_varset (data1_handle dh, const char *file)
 
 	    if (!typep)
 	    {
-		logf(LOG_WARN, "%s: class directive must precede type", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Directive class must precede type",
+		     file, lineno);
+		continue;
 	    }
 	    if (argc != 4)
 	    {
-		logf(LOG_WARN, "%s: Malformed type directive", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # or args to type", file, lineno);
+		continue;
 	    }
 	    *typep = r = (data1_vartype *)nmem_malloc(mem, sizeof(*r));
 	    r->name = nmem_strdup(mem, argv[2]);
@@ -118,7 +127,8 @@ data1_varset *data1_read_varset (data1_handle dh, const char *file)
 	    r->type = atoi(argv[1]);
 	    if (!(r->datatype = data1_maptype (dh, argv[3])))
 	    {
-		logf(LOG_WARN, "%s: Unknown datatype '%s'", file, argv[3]);
+		logf(LOG_WARN, "%s:%d: Unknown datatype '%s'",
+		     file, lineno, argv[3]);
 		fclose(f);
 		return 0;
 	    }
@@ -129,9 +139,9 @@ data1_varset *data1_read_varset (data1_handle dh, const char *file)
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s name: Expected 1 argument", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # args for name",
+		     file, lineno);
+		continue;
 	    }
 	    res->name = nmem_strdup(mem, argv[1]);
 	}
@@ -139,21 +149,21 @@ data1_varset *data1_read_varset (data1_handle dh, const char *file)
 	{
 	    if (argc != 2)
 	    {
-		logf(LOG_WARN, "%s: reference: Expected 1 argument", file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Bad # args for reference",
+		     file, lineno);
+		continue;
 	    }
 	    if ((res->reference = oid_getvalbyname(argv[1])) == VAL_NONE)
 	    {
-		logf(LOG_WARN, "Unknown reference '%s' in %s", argv[1], file);
-		fclose(f);
-		return 0;
+		logf(LOG_WARN, "%s:%d: Unknown reference '%s'",
+		     file, lineno, argv[1]);
+		continue;
 	    }
 	}
 	else 
-	    logf(LOG_WARN, "varset: Unknown directive '%s' in %s", argv[0],
-		file);
-
+	    logf(LOG_WARN, "%s:%d: Unknown directive '%s'",
+		 file, lineno, argv[0]);
+    
     fclose(f);
     return res;
 }
diff --git a/util/readconf.c b/util/readconf.c
index 6973d1f..362b596 100644
--- a/util/readconf.c
+++ b/util/readconf.c
@@ -1,10 +1,19 @@
 /*
- * Copyright (C) 1994-1997, Index Data I/S 
+ * Copyright (C) 1994-1998, Index Data
  * All rights reserved.
  * Sebastian Hammer, Adam Dickmeiss
  *
  * $Log: readconf.c,v $
- * Revision 1.5  1997-09-04 07:53:02  adam
+ * Revision 1.6  1998-10-13 16:09:55  adam
+ * Added support for arbitrary OID's for tagsets, schemas and attribute sets.
+ * Added support for multiple attribute set references and tagset references
+ * from an abstract syntax file.
+ * Fixed many bad logs-calls in routines that read the various
+ * specifications regarding data1 (*.abs,*.att,...) and made the messages
+ * consistent whenever possible.
+ * Added extra 'lineno' argument to function readconf_line.
+ *
+ * Revision 1.5  1997/09/04 07:53:02  adam
  * Added include readconf.h.
  *
  * Revision 1.4  1997/05/14 06:54:07  adam
@@ -36,21 +45,23 @@
 
 #define l_isspace(c) ((c) == '\t' || (c) == ' ' || (c) == '\n')
 
-int readconf_line(FILE *f, char *line, int len, char *argv[], int num)
+int readconf_line(FILE *f, int *lineno, char *line, int len,
+		  char *argv[], int num)
 {
     char *p;
     int argc;
-
+    
     while ((p = fgets(line, len, f)))
     {
-	while (*p && isspace(*p))
+	(*lineno)++;
+	while (*p && l_isspace(*p))
 	    p++;
 	if (*p && *p != '#')
 	    break;
     }
     if (!p)
 	return 0;
-
+    
     for (argc = 0; *p ; argc++)
     {
 	if (*p == '#')  /* trailing comment */
@@ -72,12 +83,13 @@ int readconf_line(FILE *f, char *line, int len, char *argv[], int num)
  * Read lines of a configuration file.
  */
 int readconf(char *name, void *rprivate,
-    int (*fun)(char *name, void *rprivate, int argc, char *argv[]))
+	     int (*fun)(char *name, void *rprivate, int argc, char *argv[]))
 {
     FILE *f;
     char line[512], *m_argv[50];
     int m_argc;
-
+    int lineno = 0;
+    
     if (!(f = fopen(name, "r")))
     {
 	logf(LOG_WARN|LOG_ERRNO, "readconf: %s", name);
@@ -86,8 +98,8 @@ int readconf(char *name, void *rprivate,
     for (;;)
     {
 	int res;
-
-	if (!(m_argc = readconf_line(f, line, 512, m_argv, 50)))
+	
+	if (!(m_argc = readconf_line(f, &lineno, line, 512, m_argv, 50)))
 	{
 	    fclose(f);
 	    return 0;
-- 
1.7.10.4