/*************************************************************************//*									 *//*	Source code for use with See5/C5.0 Release 1.19			 *//*	-----------------------------------------------			 *//*		      Copyright RuleQuest Research 2003			 *//*									 *//*	This code is provided "as is" without warranty of any kind,	 *//*	either express or implied.  All use is at your own risk.	 *//*									 *//*************************************************************************/#define	MAXLINEBUFFER	10000char	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.		 *//*									 *//*************************************************************************/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;}/*************************************************************************//*									 *//*	Read names of classes, attributes and legal attribute values.	 *//*	On completion, names are stored in:				 *//*	  ClassName	-	class names				 *//*	  AttName	-	attribute names				 *//*	  AttValName	-	attribute value names			 *//*	with:								 *//*	  MaxAttVal	-	number of values for each attribute	 *//*									 *//*	Other global variables set are:					 *//*	  MaxAtt	-	maximum attribute number		 *//*	  MaxClass	-	maximum class number			 *//*									 *//*	Note:  until the number of attributes is known, the name	 *//*	       information is assembled in local arrays			 *//*									 *//*************************************************************************/void GetNames(FILE *Nf)/*   --------  */{    char	Buffer[1000]="";    int		AttCeiling=100, ClassCeiling=100;    Attribute	Att;    ErrMsgs = AttExIn = 0;    LineNo  = 0;    LBp     = LineBuffer;    *LBp    = 0;    /*  Get class names from names file  */    ClassName = AllocZero(ClassCeiling, String);    MaxClass = ClassAtt = LabelAtt = 0;    do    {	ReadName(Nf, Buffer, 1000, ':');	if ( ++MaxClass >= ClassCeiling)	{	    ClassCeiling += 100;	    Realloc(ClassName, ClassCeiling, String);	}	ClassName[MaxClass] = CopyString(Buffer);    }    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 )	{	    AttCeiling += 100;	    Realloc(AttName, AttCeiling, String);	    Realloc(MaxAttVal, AttCeiling, DiscrValue);	    Realloc(AttValName, AttCeiling, String *);	    Realloc(SpecialStatus, AttCeiling, char);	    Realloc(AttDef, AttCeiling, Definition);	}	AttName[MaxAtt] = CopyString(Buffer);	SpecialStatus[MaxAtt] = Nil;	AttDef[MaxAtt] = Nil;	MaxAttVal[MaxAtt] = 0;	if ( Delimiter == '=' )	{	    if ( MaxClass == 1 && ! strcmp(ClassName[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(ClassName[1], AttName, 1, MaxAtt);	/*  Make sure not excluding class attribute  */	if ( Skip(ClassAtt) ) SpecialStatus[ClassAtt] -= SKIP;	/*  Class attribute must be present and must be discrete  */	if ( ClassAtt <= 0 )	{	    Error(NOTARGET, ClassName[1], "");	}	else	if ( Continuous(ClassAtt) ||	     StatBit(ClassAtt, DISCRETE|EXCLUDE) )	{	    Error(BADTARGET, ClassName[1], "");	}	Free(ClassName[1]);	Free(ClassName);	MaxClass  = MaxAttVal[ClassAtt];	ClassName = AttValName[ClassAtt];    }    ClassName[0] = CopyString("?");    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 *) (int) v+1;	    AttValName[MaxAtt][(MaxAttVal[MaxAtt]=1)] = CopyString("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" unless this attribute is the class  */	if ( MaxClass > 1 || strcmp(ClassName[1], AttName[MaxAtt]) )	{	    AttValName[MaxAtt][(MaxAttVal[MaxAtt]=1)] = CopyString("N/A");	}	else	{	    MaxAttVal[MaxAtt] = 0;	}	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]] = CopyString(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]] = CopyString(Buffer);	}	while ( Delimiter == ',' );	/*  Cancel ordered status if <3 real values  */	if ( Ordered(MaxAtt) && MaxAttVal[MaxAtt] <= 3 )	{	    SpecialStatus[MaxAtt] = 0;	}    }}/*************************************************************************//*									 *//*	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 );}/*************************************************************************//*									 *//*	Allocate space then copy string into it				 *//*									 *//*************************************************************************/String CopyString(String S)/*     -----------  */{    char *p;    p = Alloc(strlen(S)+1, char);    strcpy(p, S);    return p;}/*************************************************************************//*									 *//*	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++;}/*************************************************************************//*									 *//*  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. the array of		 *//*  attribute values).							 *//*									 *//*************************************************************************/#define XError(a,b,c)	Error(a,b,c)Description GetDescription(FILE *Df, Boolean Train)/*          --------------  */{    Attribute	Att;    char	name[1000], *endname;    int		Dv;    Description	Dummy, DVec;    ContValue	Cv;    Boolean	FirstValue=true;#if defined WIN32  && ! defined _CONSOLE     extern int	XREF;#endif    if ( ReadName(Df, name, 1000, '\00') )    {	Dummy = AllocZero(MaxAtt+2, AttValue);	DVec = &Dummy[1];	ForEach(Att, 1, MaxAtt)	{	    if ( AttDef[Att] )	    {		DVec[Att] = EvaluateDef(AttDef[Att], DVec);		if ( Continuous(Att) )		{		    CheckValue(DVec, Att);		}		if ( SomeMiss )		{		    SomeMiss[Att] |= Unknown(DVec, Att);		    SomeNA[Att]   |= NotApplic(DVec, Att);		}		continue;	    }	    /*  Get the attribute value if don't already have it  */	    if ( ! FirstValue && ! ReadName(Df, name, 1000, '\00') )	    {		XError(HITEOF, Fn, "");		FreeLastCase(DVec);		return Nil;	    }	    FirstValue = false;	    if ( Exclude(Att) )	    {#if defined WIN32 && ! defined _CONSOLE		if ( XREF || Att == LabelAtt )#else		if ( Att == LabelAtt )#endif		{		    /*  Record the value as a string  */		    SVal(DVec,Att) = CopyString(name);		}	    }	    else	    if ( ! strcmp(name, "?") )	    {		/*  Set marker to indicate missing value  */		DVal(DVec, Att) = UNKNOWN;		if ( SomeMiss ) SomeMiss[Att] = true;	    }	    else	    if ( Att != ClassAtt && ! strcmp(name, "N/A") )	    {		/*  Set marker to indicate not applicable  */		DVal(DVec, Att) = NA;		if ( SomeNA ) SomeNA[Att] = true;	    }	    else	    if ( Discrete(Att) )	    {		/*  Discrete attribute  */		Dv = Which(name, AttValName[Att], 1, MaxAttVal[Att]);		if ( ! Dv )		{		    if ( StatBit(Att, DISCRETE) )		    {			if ( Train )			{			    /*  Add value to list  */			    if ( MaxAttVal[Att] >= (int) AttValName[Att][0] )			    {				XError(TOOMANYVALS, AttName[Att],					 (char *) AttValName[Att][0] - 1);				Dv = MaxAttVal[Att];			    }			    else			    {				Dv = ++MaxAttVal[Att];				AttValName[Att][Dv]   = CopyString(name);				AttValName[Att][Dv+1] = "<other>"; /* no free */			    }			}			else			{			    /*  Set value to "<other>"  */			    Dv = MaxAttVal[Att] + 1;			}		    }		    else		    {			XError(BADATTVAL, AttName[Att], name);			Dv = UNKNOWN;		    }		}		DVal(DVec, Att) = Dv;	    }	    else	    {		/*  Continuous value  */		if ( TStampVal(Att) )		{		    CVal(DVec, Att) = Cv = TStampToMins(name);		    if ( Cv >= 1E9 )	/* long time in future */		    {			XError(BADTSTMP, AttName[Att], name);			DVal(DVec, Att) = UNKNOWN;		    }		}		else