see5-installer 0.1.0

data/ext/gritbot/extern.i

@@ -0,0 +1,101 @@
+/*************************************************************************/
+/*									 */
+/*  Copyright 2010 Rulequest Research Pty Ltd.				 */
+/*									 */
+/*  This file is part of GritBot GPL Edition, a single-threaded version	 */
+/*  of GritBot release 2.01.						 */
+/*									 */
+/*  GritBot GPL Edition is free software: you can redistribute it	 */
+/*  and/or modify it under the terms of the GNU General Public License	 */
+/*  as published by the Free Software Foundation, either version 3 of	 */
+/*  the License, or (at your option) any later version.			 */
+/*									 */
+/*  GritBot GPL Edition is distributed in the hope that it will be	 */
+/*  useful, but WITHOUT ANY WARRANTY; without even the implied warranty	 */
+/*  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	 */
+/*  GNU General Public License for more details.			 */
+/*									 */
+/*  You should have received a copy of the GNU General Public License	 */
+/*  (gpl.txt) along with GritBot GPL Edition.  If not, see		 */
+/*									 */
+/*      <http://www.gnu.org/licenses/>.					 */
+/*									 */
+/*************************************************************************/
+
+
+
+/*************************************************************************/
+/*									 */
+/*		External references to data in global.c			 */
+/*		---------------------------------------			 */
+/*									 */
+/*************************************************************************/
+
+extern	Attribute	ClassAtt,
+			LabelAtt;
+
+extern	int		MaxAtt,
+			MaxDiscrVal,
+			MaxLabel,
+			LineNo,
+			ErrMsgs,
+			AttExIn,
+			TSBase;
+
+extern	CaseNo		MaxCase,
+			LastDataCase;
+
+extern	Description	*Case,
+			*SaveCase;
+
+extern	DiscrValue	*MaxAttVal;
+
+extern	char		*SpecialStatus;
+
+extern	Definition	*AttDef;
+
+extern	String		*AttName,
+		  	**AttValName;
+
+extern	int		VERBOSITY,
+			MAXCONDATTS,
+			MAXOUT;
+
+extern	Boolean		SIFT,
+			LIST,
+			TargetSaved;
+
+extern	CaseCount	CMINITEMS,
+			DMINITEMS,
+			SampleSize;
+
+extern	float		MINABNORM,
+			CF;
+
+extern double		**Prior,
+			*LogCaseNo,
+			*Rand;
+extern	unsigned char	*Prec;
+extern int		LastLevel;
+	
+extern	char		Fn[500];
+
+extern	Boolean		*UseLogs,
+			*SomeMiss,
+			*SomeNA;
+
+extern	ContValue	*LowTail,
+			*HighTail;
+
+extern	Clust		*Cluster;
+extern	int		NClust,
+			ClustSpace;
+
+extern	EnvRec		GEnv;
+
+extern	FILE		*Sf;
+
+extern	Tree		T;
+
+extern	String		FileStem;
+

data/ext/gritbot/getdata.c

@@ -0,0 +1,329 @@
+/*************************************************************************/
+/*									 */
+/*  Copyright 2010 Rulequest Research Pty Ltd.				 */
+/*									 */
+/*  This file is part of GritBot GPL Edition, a single-threaded version	 */
+/*  of GritBot release 2.01.						 */
+/*									 */
+/*  GritBot GPL Edition is free software: you can redistribute it	 */
+/*  and/or modify it under the terms of the GNU General Public License	 */
+/*  as published by the Free Software Foundation, either version 3 of	 */
+/*  the License, or (at your option) any later version.			 */
+/*									 */
+/*  GritBot GPL Edition is distributed in the hope that it will be	 */
+/*  useful, but WITHOUT ANY WARRANTY; without even the implied warranty	 */
+/*  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	 */
+/*  GNU General Public License for more details.			 */
+/*									 */
+/*  You should have received a copy of the GNU General Public License	 */
+/*  (gpl.txt) along with GritBot GPL Edition.  If not, see		 */
+/*									 */
+/*      <http://www.gnu.org/licenses/>.					 */
+/*									 */
+/*************************************************************************/
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Get case descriptions from data file				 */
+/*	--------------------------------------				 */
+/*									 */
+/*************************************************************************/
+
+
+#include "defns.i"
+#include "extern.i"
+
+#define Inc 2048
+
+
+
+/*************************************************************************/
+/*									 */
+/*  Read raw case descriptions from file with given extension.		 */
+/*									 */
+/*  On completion, cases are stored in array Case in the form		 */
+/*  of descriptions (i.e. arrays of attribute values), and		 */
+/*  MaxCase is set to the number of data items.				 */
+/*									 */
+/*************************************************************************/
+
+
+void GetData(FILE *Df, Boolean Train)
+/*   -------  */
+{
+    Description	DVec;
+    CaseNo	CaseSpace;
+
+    LineNo = 0;
+
+    if ( Train )
+    {
+	MaxCase = MaxLabel = 0;
+	CaseSpace = 100;
+	Case = Alloc(CaseSpace+1, Description);	/* for error reporting */
+    }
+    else
+    {
+	MaxCase++;
+	CaseSpace = MaxCase;
+    }
+
+    while ( (DVec = GetDescription(Df, Train)) )
+    {
+	/*  Make sure there is room for another item  */
+
+	if ( MaxCase >= CaseSpace )
+	{
+	    CaseSpace += Inc;
+	    Realloc(Case, CaseSpace+1, Description);
+	}
+
+	Case[MaxCase] = DVec;
+	MaxCase++;
+    }
+
+    fclose(Df);
+    MaxCase--;
+
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*  Read a raw case description from file Df.				 */
+/*									 */
+/*  For each attribute, read the attribute value from the file.		 */
+/*  If it is a discrete valued attribute, find the associated no.	 */
+/*  of this attribute value (if the value is unknown this is 0).	 */
+/*									 */
+/*  Returns the description of the case (i.e. a pointer to the array	 */
+/*  of attribute values).						 */
+/*									 */
+/*************************************************************************/
+
+
+Description GetDescription(FILE *Df, Boolean Train)
+/*          --------------  */
+{
+    Attribute	Att;
+    char	name[1000], *endname;
+    int		Dv, Chars;
+    ContValue	Cv;
+    Description	DVec;
+    Boolean	FirstValue=true;
+
+    if ( ReadName(Df, name, 1000, '\00') )
+    {
+	Case[MaxCase] = DVec = NewCase();
+
+	OutXVal(DVec) = 1.0;
+	OutClust(DVec) = Nil;
+
+	ForEach(Att, 1, MaxAtt)
+	{
+	    if ( AttDef[Att] )
+	    {
+		DVec[Att] = EvaluateDef(AttDef[Att], DVec);
+
+		if ( Continuous(Att) )
+		{
+		    CheckValue(DVec, Att);
+		}
+
+		continue;
+	    }
+
+	    /*  Get the attribute value if don't already have it  */
+
+	    if ( ! FirstValue && ! ReadName(Df, name, 1000, '\00') )
+	    {
+		Error(HITEOF, AttName[Att], "");
+		FreeLastCase(DVec);
+		return Nil;
+	    }
+	    FirstValue = false;
+
+	    if ( Exclude(Att) )
+	    {
+		if ( Att == LabelAtt )
+		{
+		    /*  Record the value as a string  */
+
+		    SVal(DVec,Att) = Alloc(strlen(name)+1, char);
+		    strcpy(SVal(DVec,Att), name);
+		}
+	    }
+	    else
+	    if ( ! ( strcmp(name, "?") ) )
+	    {
+		/*  Set marker to indicate missing value  */
+
+		DVal(DVec, Att) = UNKNOWN;
+	    }
+	    else
+	    if ( ! strcmp(name, "N/A") )
+	    {
+		/*  Set marker to indicate not applicable  */
+
+		DVal(DVec, Att) = NA;
+	    }
+	    else
+	    if ( Discrete(Att) )
+	    {
+		Dv = Which(name, AttValName[Att], 1, MaxAttVal[Att]);
+		if ( ! Dv )
+		{
+		    if ( StatBit(Att, DISCRETE) )
+		    {
+			if ( ! strcmp("cases", Fn + strlen(Fn) - 5) )
+			{
+			    /*  This is a gritcheck  */
+
+			    Dv = UNKNOWN;
+			}
+			else
+			{
+			    /*  Add value to list  */
+
+			    if ( MaxAttVal[Att] >= (long) AttValName[Att][0] )
+			    {
+				Error(TOOMANYVALS, AttName[Att],
+					 (char *) AttValName[Att][0] - 1);
+				Dv = MaxAttVal[Att];
+			    }
+			    else
+			    {
+				Dv = ++MaxAttVal[Att];
+				AttValName[Att][Dv]   = strdup(name);
+				AttValName[Att][Dv+1] = "<other>"; /* no free */
+			    }
+
+			    if ( Dv > MaxDiscrVal )
+			    {
+				MaxDiscrVal = Dv;
+			    }
+			}
+		    }
+		    else
+		    {
+			Error(BADATTVAL, AttName[Att], name);
+		    }
+		}
+		DVal(DVec, Att) = Dv;
+	    }
+	    else
+	    {
+		/*  Continuous value  */
+
+		if ( TStampVal(Att) )
+		{
+		    CVal(DVec, Att) = Cv = TStampToMins(name);
+		    if ( Cv >= 1E9 )	/* long time in future */
+		    {
+			Error(BADTSTMP, AttName[Att], name);
+			DVal(DVec, Att) = UNKNOWN;
+		    }
+		}
+		else
+		if ( DateVal(Att) )
+		{
+		    CVal(DVec, Att) = Cv = DateToDay(name);
+		    if ( Cv < 1 )
+		    {
+			Error(BADDATE, AttName[Att], name);
+			DVal(DVec, Att) = UNKNOWN;
+		    }
+		}
+		else
+		if ( TimeVal(Att) )
+		{
+		    CVal(DVec, Att) = Cv = TimeToSecs(name);
+		    if ( Cv < 0 )
+		    {
+			Error(BADTIME, AttName[Att], name);
+			DVal(DVec, Att) = UNKNOWN;
+		    }
+		}
+		else
+		{
+		    CVal(DVec, Att) = strtod(name, &endname);
+		    if ( endname == name || *endname != '\0' )
+		    {
+			Error(BADATTVAL, AttName[Att], name);
+			DVal(DVec, Att) = UNKNOWN;
+		    }
+		}
+
+		CheckValue(DVec, Att);
+	    }
+	}
+
+	if ( LabelAtt && (Chars = strlen(SVal(DVec, LabelAtt))) > MaxLabel )
+	{
+	    MaxLabel = Chars;
+	}
+
+	return DVec;
+    }
+    else
+    {
+	return Nil;
+    }
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Free case description space					 */
+/*									 */
+/*************************************************************************/
+
+
+void FreeData()
+/*   --------  */
+{
+    CaseNo	i;
+
+    /*  Release any strings holding case labels  */
+
+    if ( LabelAtt )
+    {
+	ForEach(i, 0, MaxCase)
+	{
+	    FreeUnlessNil(SVal(Case[i],LabelAtt));
+	}
+    }
+
+    FreeCases();
+
+    Free(Case);						Case = Nil;
+    MaxCase = -1;
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Check for bad continuous value					 */
+/*									 */
+/*************************************************************************/
+
+
+void CheckValue(Description DVec, Attribute Att)
+/*   ----------  */
+{
+    ContValue	Cv;
+
+    Cv = CVal(DVec, Att);
+    if ( ! finite(Cv) )
+    {
+	Error(BADNUMBER, AttName[Att], "");
+
+	CVal(DVec, Att) = UNKNOWN;
+	DVal(DVec, Att) = 0;
+    }
+}

data/ext/gritbot/getnames.c

@@ -0,0 +1,573 @@
+/*************************************************************************/
+/*									 */
+/*  Copyright 2010 Rulequest Research Pty Ltd.				 */
+/*									 */
+/*  This file is part of GritBot GPL Edition, a single-threaded version	 */
+/*  of GritBot release 2.01.						 */
+/*									 */
+/*  GritBot GPL Edition is free software: you can redistribute it	 */
+/*  and/or modify it under the terms of the GNU General Public License	 */
+/*  as published by the Free Software Foundation, either version 3 of	 */
+/*  the License, or (at your option) any later version.			 */
+/*									 */
+/*  GritBot GPL Edition is distributed in the hope that it will be	 */
+/*  useful, but WITHOUT ANY WARRANTY; without even the implied warranty	 */
+/*  of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the	 */
+/*  GNU General Public License for more details.			 */
+/*									 */
+/*  You should have received a copy of the GNU General Public License	 */
+/*  (gpl.txt) along with GritBot GPL Edition.  If not, see		 */
+/*									 */
+/*      <http://www.gnu.org/licenses/>.					 */
+/*									 */
+/*************************************************************************/
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Get names of classes, attributes and attribute values		 */
+/*	-----------------------------------------------------		 */
+/*									 */
+/*************************************************************************/
+
+
+#include "defns.i"
+#include "extern.i"
+
+#include <sys/types.h>
+#include <sys/stat.h>
+
+#define	MAXLINEBUFFER	10000
+int	Delimiter;
+char	LineBuffer[MAXLINEBUFFER], *LBp=LineBuffer;
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Read a name from file f into string s, setting Delimiter.	 */
+/*									 */
+/*	- Embedded periods are permitted, but periods followed by space	 */
+/*	  characters act as delimiters.					 */
+/*	- Embedded spaces are permitted, but multiple spaces are	 */
+/*	  replaced by a single space.					 */
+/*	- Any character can be escaped by '\'.				 */
+/*	- The remainder of a line following '|' is ignored.		 */
+/*									 */
+/*	Colons are sometimes delimiters depending on ColonOpt		 */
+/*									 */
+/*************************************************************************/
+
+
+Boolean ReadName(FILE *f, String s, int n, char ColonOpt)
+/*      --------  */
+{
+    register char *Sp=s;
+    register int  c;
+    char	  Msg[2];
+
+    /*  Skip to first non-space character  */
+
+    while ( (c = InChar(f)) == '|' || Space(c) )
+    {
+	if ( c == '|' ) SkipComment;
+    }
+
+    /*  Return false if no names to read  */
+
+    if ( c == EOF )
+    {
+	Delimiter = EOF;
+	return false;
+    }
+
+    /*  Read in characters up to the next delimiter  */
+
+    while ( c != ColonOpt && c != ',' && c != '\n' && c != '|' && c != EOF )
+    {
+	if ( --n <= 0 )
+	{
+	    if ( Of ) Error(LONGNAME, "", "");
+	}
+
+	if ( c == '.' )
+	{
+	    if ( (c = InChar(f)) == '|' || Space(c) || c == EOF ) break;
+	    *Sp++ = '.';
+	    continue;
+	}
+
+	if ( c == '\\' )
+	{
+	    c = InChar(f);
+	}
+
+	if ( Space(c) )
+	{
+	    *Sp++ = ' ';
+
+	    while ( ( c = InChar(f) ) == ' ' || c == '\t' )
+		;
+	}
+	else
+	{
+	    *Sp++ = c;
+	    c = InChar(f);
+	}
+    }
+
+    if ( c == '|' ) SkipComment;
+    Delimiter = c;
+
+    /*  Special case for ':='  */
+
+    if ( Delimiter == ':' )
+    {
+	if ( *LBp == '=' )
+	{
+	    Delimiter = '=';
+	    LBp++;
+	}
+    }
+
+    /*  Strip trailing spaces  */
+
+    while ( Sp > s && Space(*(Sp-1)) ) Sp--;
+
+    if ( Sp == s )
+    {
+	Msg[0] = ( Space(c) ? '.' : c );
+	Msg[1] = '\00';
+	Error(MISSNAME, Fn, Msg);
+    }
+
+    *Sp++ = '\0';
+    return true;
+}
+
+
+
+#ifndef INSPECT
+/*************************************************************************/
+/*									 */
+/*	Read names of classes, attributes and legal attribute values.	 */
+/*	On completion, names are stored in:				 */
+/*	  AttName	-	attribute names				 */
+/*	  AttValName	-	attribute value names			 */
+/*	with:								 */
+/*	  MaxAttVal	-	number of values for each attribute	 */
+/*									 */
+/*	Other global variables set are:					 */
+/*	  MaxAtt	-	maximum attribute number		 */
+/*	  MaxDiscrVal	-	maximum discrete values for an attribute */
+/*									 */
+/*************************************************************************/
+
+
+void GetNames(FILE *Nf)
+/*   --------  */
+{
+    char	Buffer[1000]="";
+    int		AttCeiling=100, ClassCeiling=100;
+    DiscrValue	MaxClass=0, v;
+    String	*ExplicitClass;
+    Attribute	Att;
+
+    ErrMsgs = AttExIn = 0;
+    LineNo  = 0;
+
+    /*  Get class names from names file  */
+
+    ExplicitClass = AllocZero(ClassCeiling, String);
+    ClassAtt = LabelAtt = 0;
+    do
+    {
+	ReadName(Nf, Buffer, 1000, ':');
+
+	if ( ++MaxClass >= ClassCeiling)
+	{
+	    ClassCeiling += 100;
+	    Realloc(ExplicitClass, ClassCeiling, String);
+	}
+	ExplicitClass[MaxClass] = strdup(Buffer);
+    }
+    while ( Delimiter == ',' );
+
+    /*  Ignore thresholds for See5/C5.0 continuous class attribute  */
+
+    if ( Delimiter == ':' )
+    {
+	do
+	{
+	    ReadName(Nf, Buffer, 1000, ':');
+	}
+	while ( Delimiter == ',' );
+    }
+
+    /*  Get attribute and attribute value names from names file  */
+
+    AttName = AllocZero(AttCeiling, String);
+    MaxAttVal = AllocZero(AttCeiling, DiscrValue);
+    AttValName = AllocZero(AttCeiling, String *);
+    SpecialStatus = AllocZero(AttCeiling, char);
+    AttDef = AllocZero(AttCeiling, Definition);
+
+    MaxAtt = 0;
+    while ( ReadName(Nf, Buffer, 1000, ':') )
+    {
+	if ( Delimiter != ':' && Delimiter != '=' )
+	{
+	    Error(BADATTNAME, Buffer, "");
+	}
+
+	/*  Check for include/exclude instruction  */
+
+	if ( ( *Buffer == 'a' || *Buffer == 'A' ) &&
+	     ! memcmp(Buffer+1, "ttributes ", 10) &&
+	     ! memcmp(Buffer+strlen(Buffer)-6, "cluded", 6) )
+	{
+	    AttExIn = ( ! memcmp(Buffer+strlen(Buffer)-8, "in", 2) ? 1 : -1 );
+	    if ( AttExIn == 1 )
+	    {
+		ForEach(Att, 1, MaxAtt)
+		{
+		    SpecialStatus[Att] |= SKIP;
+		}
+	    }
+
+	    while ( ReadName(Nf, Buffer, 1000, ':') )
+	    {
+		Att = Which(Buffer, AttName, 1, MaxAtt);
+		if ( ! Att )
+		{
+		    Error(UNKNOWNATT, Buffer, Nil);
+		}
+		else
+		if ( AttExIn == 1 )
+		{
+		    SpecialStatus[Att] -= SKIP;
+		}
+		else
+		{
+		    SpecialStatus[Att] |= SKIP;
+		}
+	    }
+
+	    break;
+	}
+
+	if ( Which(Buffer, AttName, 1, MaxAtt) > 0 )
+	{
+	    Error(DUPATTNAME, Buffer, Nil);
+	}
+
+	if ( ++MaxAtt >= AttCeiling-1 )		/* ensure space for class att */
+	{
+	    AttCeiling += 100;
+	    Realloc(AttName, AttCeiling, String);
+	    Realloc(MaxAttVal, AttCeiling, DiscrValue);
+	    Realloc(AttValName, AttCeiling, String *);
+	    Realloc(SpecialStatus, AttCeiling, char);
+	    Realloc(AttDef, AttCeiling, Definition);
+	}
+
+	AttName[MaxAtt] = strdup(Buffer);
+	SpecialStatus[MaxAtt] = Nil;
+	AttDef[MaxAtt] = Nil;
+	MaxAttVal[MaxAtt] = 0;
+
+	if ( Delimiter == '=' )
+	{
+	    if ( MaxClass == 1 && ! strcmp(ExplicitClass[1], AttName[MaxAtt]) )
+	    {
+		Error(BADDEF3, Nil, Nil);
+	    }
+
+	    ImplicitAtt(Nf);
+	}
+	else
+	{
+	    ExplicitAtt(Nf);
+	}
+    }
+
+    /*  Check whether class is one of the attributes  */
+
+    if ( MaxClass == 1 )
+    {
+	ClassAtt = Which(ExplicitClass[1], AttName, 1, MaxAtt);
+	Free(ExplicitClass[1]);
+	Free(ExplicitClass);
+    }
+    else
+    {
+	MaxAtt++;
+	AttName[MaxAtt] = strdup("class");
+
+	/*  Set up last attribute with values "N/A" and explicit classes  */
+
+	AttValName[MaxAtt] = Alloc(MaxClass+2, String);
+	AttValName[MaxAtt][1] = strdup("N/A");
+	ForEach(v, 1, MaxClass)
+	{
+	    AttValName[MaxAtt][v+1] = ExplicitClass[v];
+	}
+	Free(ExplicitClass);
+
+	MaxAttVal[MaxAtt]  = MaxClass+1;
+	MaxDiscrVal	   = Max(MaxDiscrVal, MaxClass+1);
+
+	AttDef[MaxAtt] = Nil;
+	SpecialStatus[MaxAtt] = ( AttExIn == 1 ? SKIP : 0 );
+    }
+
+    fclose(Nf);
+
+    if ( ErrMsgs > 0 ) Goodbye(1);
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Continuous or discrete attribute				 */
+/*									 */
+/*************************************************************************/
+
+
+void ExplicitAtt(FILE *Nf)
+/*   -----------  */
+{
+    char	Buffer[1000]="", *p;
+    DiscrValue	v;
+    int		ValCeiling=100, BaseYear;
+    time_t	clock;
+
+    /*  Read attribute type or first discrete value  */
+
+    if ( ! ( ReadName(Nf, Buffer, 1000, ':') ) )
+    {
+	Error(EOFINATT, AttName[MaxAtt], "");
+    }
+
+    MaxAttVal[MaxAtt] = 0;
+
+    if ( Delimiter != ',' )
+    {
+	/*  Typed attribute  */
+
+	if ( ! strcmp(Buffer, "continuous") )
+	{
+	}
+	else
+	if ( ! strcmp(Buffer, "timestamp") )
+	{
+	    SpecialStatus[MaxAtt] = TSTMPVAL;
+
+	    /*  Set the base date if not done already  */
+
+	    if ( ! TSBase )
+	    {
+		clock = time(0);
+		BaseYear = gmtime(&clock)->tm_year + 1900;
+		SetTSBase(BaseYear);
+	    }
+	}
+	else
+	if ( ! strcmp(Buffer, "date") )
+	{
+	    SpecialStatus[MaxAtt] = DATEVAL;
+	}
+	else
+	if ( ! strcmp(Buffer, "time") )
+	{
+	    SpecialStatus[MaxAtt] = STIMEVAL;
+	}
+	else
+	if ( ! memcmp(Buffer, "discrete", 8) )
+	{
+	    SpecialStatus[MaxAtt] = DISCRETE;
+
+	    /*  Read max values and reserve space  */
+
+	    v = atoi(&Buffer[8]);
+	    if ( v < 2 )
+	    {
+		Error(BADDISCRETE, AttName[MaxAtt], "");
+	    }
+
+	    AttValName[MaxAtt] = Alloc(v+3, String);
+	    AttValName[MaxAtt][0] = (char *) (long) v+1;
+	    AttValName[MaxAtt][(MaxAttVal[MaxAtt]=1)] = strdup("N/A");
+	}
+	else
+	if ( ! strcmp(Buffer, "ignore") )
+	{
+	    SpecialStatus[MaxAtt] = EXCLUDE;
+	}
+	else
+	if ( ! strcmp(Buffer, "label") )
+	{
+	    LabelAtt = MaxAtt;
+	    SpecialStatus[MaxAtt] = EXCLUDE;
+	}
+	else
+	{
+	    /*  Cannot have only one discrete value for an attribute  */
+
+	    Error(SINGLEATTVAL, AttName[MaxAtt], Buffer);
+	}
+    }
+    else
+    {
+	/*  Discrete attribute with explicit values  */
+
+	AttValName[MaxAtt] = AllocZero(ValCeiling, String);
+
+	/*  Add "N/A"  */
+
+	AttValName[MaxAtt][(MaxAttVal[MaxAtt]=1)] = strdup("N/A");
+
+	p = Buffer;
+
+	/*  Special check for ordered attribute  */
+
+	if ( ! memcmp(Buffer, "[ordered]", 9) )
+	{
+	    SpecialStatus[MaxAtt] = ORDERED;
+
+	    for ( p = Buffer+9 ; Space(*p) ; p++ )
+		;
+	}
+
+	/*  Record first real explicit value  */
+
+	AttValName[MaxAtt][++MaxAttVal[MaxAtt]] = strdup(p);
+
+	/*  Record remaining values  */
+
+	do
+	{
+	    if ( ! ( ReadName(Nf, Buffer, 1000, ':') ) )
+	    {
+		Error(EOFINATT, AttName[MaxAtt], "");
+	    }
+
+	    if ( ++MaxAttVal[MaxAtt] >= ValCeiling )
+	    {
+		ValCeiling += 100;
+		Realloc(AttValName[MaxAtt], ValCeiling, String);
+	    }
+
+	    AttValName[MaxAtt][MaxAttVal[MaxAtt]] = strdup(Buffer);
+	}
+	while ( Delimiter == ',' );
+
+	/*  Cancel ordered status if <3 real values  */
+
+	if ( Ordered(MaxAtt) && MaxAttVal[MaxAtt] <= 3 )
+	{
+	    SpecialStatus[MaxAtt] = 0;
+	}
+	if ( MaxAttVal[MaxAtt] > MaxDiscrVal ) MaxDiscrVal = MaxAttVal[MaxAtt];
+    }
+}
+#endif
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Locate value Val in List[First] to List[Last]			 */
+/*									 */
+/*************************************************************************/
+
+
+int Which(String Val, String *List, int First, int Last)
+/*  -----  */
+{
+    int	n=First;
+
+    while ( n <= Last && strcmp(Val, List[n]) ) n++;
+
+    return ( n <= Last ? n : First-1 );
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Free up all space allocated by GetNames()			 */
+/*									 */
+/*************************************************************************/
+
+
+void FreeNames()
+/*   ---------  */
+{
+    Attribute a, t;
+
+    ForEach(a, 1, MaxAtt)
+    {
+	if ( Discrete(a) )
+	{
+	    FreeVector((void **) AttValName[a], 1, MaxAttVal[a]);
+	}
+    }
+    FreeUnlessNil(AttValName);				AttValName = Nil;
+    FreeUnlessNil(MaxAttVal);				MaxAttVal = Nil;
+    FreeVector((void **) AttName, 1, MaxAtt);		AttName = Nil;
+
+    FreeUnlessNil(SpecialStatus);			SpecialStatus = Nil;
+
+    /*  Definitions (if any)  */
+
+    if ( AttDef )
+    {
+	ForEach(a, 1, MaxAtt)
+	{
+	    if ( AttDef[a] )
+	    {
+		for ( t = 0 ; DefOp(AttDef[a][t]) != OP_END ; t++ )
+		{
+		    if ( DefOp(AttDef[a][t]) == OP_STR )
+		    {
+			Free(DefSVal(AttDef[a][t]));
+		    }
+		}
+
+		Free(AttDef[a]);
+	    }
+	}
+	Free(AttDef);					AttDef = Nil;
+    }
+}
+
+
+
+/*************************************************************************/
+/*									 */
+/*	Read next char keeping track of line numbers			 */
+/*									 */
+/*************************************************************************/
+
+
+int InChar(FILE *f)
+/*  ------  */
+{
+    if ( ! *LBp )
+    {
+	LBp = LineBuffer;
+
+	if ( ! fgets(LineBuffer, MAXLINEBUFFER, f) )
+	{
+	    LineBuffer[0] = '\00';
+	    return EOF;
+	}
+
+	LineNo++;
+    }
+	
+    return (int) *LBp++;
+}