clipslibwrap_old.cpp

clips专家系统内核打包类,很有参考性.

****************************************************************************/
bool CCLIPSWrap::CLIPSFindDefglobal(CString& theVar)
{
	INITCHK(false)
	SETMBUF((LPCSTR)theVar)
	globalPtr = (struct defglobal *) FindDefglobal(m_buf);
	if(globalPtr == NULL)	{
		return false;
	}
	return true;
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSUndefglobal(void)
		Author		: Mark Tomlinson
		Desc.		: uses globalPtr, updates globalPtr
		Returns 	: true  on success, false on error
****************************************************************************/
bool CCLIPSWrap::CLIPSUndefglobal(void* pGlobal)
{										
	INITCHK(false)
	if(pGlobal == NULL)	{
		if(globalPtr == NULL)	{
			return false;
		}
		else	{
			if(Undefglobal(globalPtr))	{
				globalPtr = NULL;
				return true;
			}
		}
	}
	else	{
		if(Undefglobal(pGlobal))	{
			return true;
		}
	}
	return false;
}

/****************************************************************************
		Function	: CCLIPSWrap::SetConstruct(CString& theVar)
		Author		: Mark Tomlinson
		Desc.		: sets the construct:
			ex. "(defglobal ?*x* = 3)"
		Returns 	: true  on success, false on Error
****************************************************************************/
bool CCLIPSWrap::SetConstruct(CString& theVar)
{
	INITCHK(false)
	SETMBUF((LPCSTR)theVar)
	if(OpenStringSource("load-my-construct",m_buf,0) == 0)	{
		return false;
	}
	if(LoadConstructsFromLogicalName("load-construct") == 0)	{
		CloseStringSource("load-my-construct");
		return false;
		}
	CloseStringSource("load-my-construct");
	return true;
}

/****************************************************************************
		Function	: CCLIPSWrap::GetAllFacts(CStringArray& buffer)
		Author		: Mark Tomlinson
		Desc.		: returns all facts in buffer
		Returns 	: true on success, false on error or if no facts retrieved
****************************************************************************/
bool CCLIPSWrap::GetAllFacts(CStringArray& buffer)
{
	CString	temp;

	//reset factPtr to initial fact
	factPtr = (struct fact *) GetNextFact(NULL);
	//start looping
	while(CLIPSNextFactString(temp))	{
		buffer.Add(temp);
		}
	if(buffer.GetSize() == 0)	{
		return false;
		}
	return true;
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSMemUsed(void)
		Author		: Mark Tomlinson
		Desc.		: returns amount of memory CLIPS has
		Returns 	: memused
****************************************************************************/
long int CCLIPSWrap::CLIPSMemUsed(void)
{
	return MemUsed();
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSBatch(void)
		Author		: Mark Tomlinson
		Desc.		: access the Batch Command
		Returns 	: memused
****************************************************************************/
bool CCLIPSWrap::CLIPSBatch(CString& FileName)
{
	char	var[256];
	int i, j;

	memset(var,0,256);
	strcpy(var,(LPCSTR)(*FileName));
	j = strlen(var);
	//insure we convert backslash to forwardslash
	for(i = 0;i < j;i++)	{
		if(var[i] == '\\')	{
			var[i] = '/';
		}
	}
	return BOOLCHK(Batch(var));
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSBatchStar(void)
		Author		: Mark Tomlinson
		Desc.		: access the Batch* Command
		Returns 	: memused
****************************************************************************/
bool CCLIPSWrap::CLIPSBatchStar(CString& FileName)
{
	char	var[256];
	int i, j;
	OFSTRUCT	of;

	memset(var,0,256);
	strcpy(var,(LPCSTR)(FileName));
	j = strlen(var);
	//insure we convert backslash to forwardslash
	for(i = 0;i < j;i++)	{
		if(var[i] == '\\')	{
			var[i] = '/';
		}
	}
//	validate file exists...
	if(OpenFile(var,&of,OF_EXIST) == HFILE_ERROR)	{
		return BOOLCHK(BatchStar(var));
	}
	else	{
		return false;
	}
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSFreeMem(void)
		Author		: Mark Tomlinson
		Desc.		: attempts to free all of clips memory
		Returns 	: memused
****************************************************************************/
void CCLIPSWrap::CLIPSFreeMem()
{    
	 Reset();
	 Clear();
	 FreeAtomicValueStorage();
	 ReleaseMem(-1L, CLIPS_TRUE);
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSSetHaltExecution(void)
		Author		: Mark Tomlinson
		Desc.		: sets the CLIPS halt flag
		Returns 	: memused
****************************************************************************/
void CCLIPSWrap::CLIPSSetHaltExecution(bool mode)
{
	if(mode)	{
		SetHaltExecution(CLIPS_TRUE);
	}
	else	{
		SetHaltExecution(CLIPS_FALSE);
	}
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSMakeInstance(CString& Data)
		Author		: Mark Tomlinson
		Desc.		: creates a new COOL object, sets instancePtr to new instance
					  (ex. "(Test of MINE)", assuming a definstance of MINE)
		Returns 	: true on success, otherwise false
****************************************************************************/
bool CCLIPSWrap::CLIPSMakeInstance(CString& Data)
{
	INITCHK(false)
	SETMBUF((LPCSTR)Data)
	//attempt the MakeInstance call
	if((instancePtr = (struct instance *) MakeInstance(m_buf)) == NULL)	{
		return false;
	}
	return true;
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSFindInstance(CString& Name = NULL)
		Author	    : Mark Tomlinson
		Desc.		: locates a COOL object, sets instancePtr to found obj.
					   (ex. "Test", given the above example)
		Returns 	: true on success, otherwise false
****************************************************************************/
bool CCLIPSWrap::CLIPSFindInstance(CString& Name, bool SearchImports)
{
	INITCHK(false)
	SETMBUF((LPCSTR)Name)
	if((instancePtr = (struct instance *) FindInstance(modulePtr,m_buf,SearchImports)) == NULL)	{
		return false;
	}
	return true;
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSDeleteInstance()
		Author		: Mark Tomlinson
		Desc.		: deletes current instance
		Returns 	: true on success, otherwise false
****************************************************************************/
bool CCLIPSWrap::CLIPSDeleteInstance(void* Instance)
{
	bool	ret = false;

	INITCHK(false)
	if((instancePtr == NULL) && 
		(Instance == NULL))	{
		return false;
	}
	if(CLIPSValidInstance(Instance))	{
		if(Instance == NULL)	{
			ret = DeleteInstance(instancePtr) ? true : false;
			instancePtr = NULL;
		}
		else	{
			ret = DeleteInstance(Instance) ? true : false;
		}
	}
	return ret;
}

/****************************************************************************
		Function	: CCLIPSWrap::DeleteAllInstances()
		Author		: Mark Tomlinson
		Desc.		: deletes all instances
		Returns 	: true on success, otherwise false
****************************************************************************/
bool CCLIPSWrap::DeleteAllInstances(void)
{
	INITCHK(false)
	instancePtr = NULL;
	return BOOLCHK(DeleteInstance(NULL));
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSGetNextInstanceInClass(void)
		Author		: Mark Tomlinson
		Desc.		: Accessor for CLIPS function	GetNextInstanceInClass():
					  uses classPtr. updates instancePtr.
		Returns 	: true on success, false on error
****************************************************************************/
bool CCLIPSWrap::CLIPSGetNextInstanceInClass(void *pClass)
{
	INITCHK(false)
	if(pClass == NULL)	{
		if(classPtr == NULL)	{
			return false;
		}
		else	{
			instancePtr = (struct instance *) GetNextInstanceInClass(classPtr,instancePtr);
		}
	}
	else	{
		instancePtr = (struct instance *) GetNextInstanceInClass(pClass,instancePtr);
	}
	if(instancePtr == NULL)	{
		return false;
	}
	return true;
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSGetInstancePPForm(CString& Data)
		Author		: Mark Tomlinson
		Desc.		: Accessor for CLIPS function	GetInstancePPForm():
		Returns 	: true on success, false on error
****************************************************************************/
bool	CCLIPSWrap::CLIPSGetInstancePPForm(CString& Data, void *pInst)
{									 
	INITCHK(false)
	CLEARMBUF
	if(pInst == NULL)	{
		if(instancePtr == NULL)	{
			return false;
		}
		else	{
			GetInstancePPForm(m_buf,MBUFSIZE - 1,instancePtr);
		}
	}
	else	{
		GetInstancePPForm(m_buf,MBUFSIZE - 1,pInst);
	}
	if(strlen(m_buf) > 0)	{
		Data = m_buf;
		return true;
	}
	return false;
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSGetGlobalNumberOfInstances()
		Author		: Mark Tomlinson
		Desc.		: Accessor for CLIPS function	GetGlobalNumberOfInstances():
		Returns 	: total number of instances, all modules
****************************************************************************/
unsigned long CCLIPSWrap::CLIPSGetGlobalNumberOfInstances(void)
{
	INITCHK(false)
	return GetGlobalNumberOfInstances();
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSDirectGetSlot(CString& Slot, CString& Value)
		Author		: Mark Tomlinson
		Desc.		: Accessor for CLIPS function DirectGetSlot()
						(slot names are case sensitive)
		Returns 	: true on success, false on Error
****************************************************************************/
bool CCLIPSWrap::CLIPSDirectGetSlot(CString& Class, CString& Slot, CString& Value)
{
	struct	dataObject value;
	long	temp_l = 0,
			begin,										
			end;
	double	temp_f = 0.0;
	struct multifield *segment;			  
	struct field	  *theMultifield;
	int				   j;
	CString			   data;

	INITCHK(false)
	CLEARMBUF
	if(!CLIPSFindInstance(Class, true))	{
		return false;
	}
	SETMBUF((LPCSTR)Slot)
	DirectGetSlot(instancePtr, m_buf, &value);

	CLEARMBUF
	switch(value.type)	{
	case FLOAT:
		sprintf(m_buf,"%f", DOToFloat(value));
		Value = m_buf;
		break;
	case INTEGER:
		sprintf(m_buf, "%d", DOToInteger(value));
		Value = m_buf;
		break;
	case SYMBOL:
	case STRING:
		Value = (char *)DOToString(value);
		break;
	case MULTIFIELD:
			//get the multifield start and end values from the slot
            begin = value.begin;
			end   = value.end;
			//now get the multifield segment address from the slot
			segment = (struct multifield *) value.value;
			//get the multifield array from the multifield segment
			theMultifield = segment->theFields;
			//start att he begining index
			j = begin;
			while (j <= end)     {
				CLEARMBUF
				//get the TYPE of each of the individual fields
				switch(theMultifield[j].type)	{
			    case FLOAT:
					sprintf(m_buf,"%lf", ValueToDouble(theMultifield[j].value));
					data += m_buf;
					break;
				case INTEGER:
					sprintf(m_buf, "%ld", ValueToLong(theMultifield[j].value));
					data += m_buf;
					break;
				case SYMBOL:
					data += ValueToString(theMultifield[j].value);
					break;
			    case STRING:
					data += ValueToString(theMultifield[j].value);
			        break;
				case EXTERNAL_ADDRESS:
			        data += "<Pointer-";
					sprintf(m_buf, "%p", theMultifield[j].value);
					data += m_buf;
			        data += ">";
			        break;
				case INSTANCE_NAME:
			        data += ValueToString(theMultifield[j].value);
					break;
				case RVOID:
					break;
				default:
					data += "<unknown atomic type>";
					break;
				}
		      j++;
			  if (j <= end)	{
				  data += " ";
			  }
			}
			Value = data;
	   break;
	case EXTERNAL_ADDRESS:
	case FACT_ADDRESS:
	case INSTANCE_ADDRESS:
		sprintf(m_buf, "%ld", DOToLong(value));
		Value = m_buf;
		break;
	case INSTANCE_NAME:
		Value = (char *)DOToString(value);
		break;
	case RVOID:
		break;
	default:
		data += "<unknown atomic type>";
		Value = data;
		break;
	}
	return true;
}

/****************************************************************************
		Function	: CCLIPSWrap::CLIPSDirectPutSlot(CString& Slot, CString& Value, int type)
		Author		: Mark Tomlinson
		Desc.		: Accessor for CLIPS function DirectPutSlot()
					  (slo