From: Adam Dickmeiss <adam@indexdata.dk>
Date: Tue, 13 Oct 1998 16:09:45 +0000 (+0000)
Subject: Added support for arbitrary OID's for tagsets, schemas and attribute sets.
X-Git-Tag: YAZ.1.8~443
X-Git-Url: http://git.indexdata.com/?p=yaz-moved-to-github.git;a=commitdiff_plain;h=db9513f9eca4ef13d3cea779a695bb822fd973a9

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.
---

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;