globle void FactCommandDefinitions(
void *theEnv)
{
#if ! RUN_TIME
#if DEBUGGING_FUNCTIONS
EnvDefineFunction2(theEnv,(char*)"facts", 'v', PTIEF FactsCommand, (char*)"FactsCommand", (char*)"*4iu");
#endif
EnvDefineFunction(theEnv,(char*)"assert", 'u', PTIEF AssertCommand, (char*)"AssertCommand");
EnvDefineFunction2(theEnv,(char*)"retract", 'v', PTIEF RetractCommand, (char*)"RetractCommand",(char*)"1*z");
EnvDefineFunction2(theEnv,(char*)"assert-string", 'u', PTIEF AssertStringFunction, (char*)"AssertStringFunction", (char*)"11s");
EnvDefineFunction2(theEnv,(char*)"str-assert", 'u', PTIEF AssertStringFunction, (char*)"AssertStringFunction", (char*)"11s");
EnvDefineFunction2(theEnv,(char*)"get-fact-duplication",'b',
GetFactDuplicationCommand,(char*)"GetFactDuplicationCommand", (char*)"00");
EnvDefineFunction2(theEnv,(char*)"set-fact-duplication",'b',
SetFactDuplicationCommand,(char*)"SetFactDuplicationCommand", (char*)"11");
EnvDefineFunction2(theEnv,(char*)"save-facts", 'b', PTIEF SaveFactsCommand, (char*)"SaveFactsCommand", (char*)"1*wk");
EnvDefineFunction2(theEnv,(char*)"load-facts", 'b', PTIEF LoadFactsCommand, (char*)"LoadFactsCommand", (char*)"11k");
EnvDefineFunction2(theEnv,(char*)"fact-index", 'g', PTIEF FactIndexFunction,(char*)"FactIndexFunction", (char*)"11y");
AddFunctionParser(theEnv,(char*)"assert",AssertParse);
FuncSeqOvlFlags(theEnv,(char*)"assert",FALSE,FALSE);
#else
#if MAC_MCW || WIN_MCW || MAC_XCD
#pragma unused(theEnv)
#endif
#endif
}
globle void FactCommandDefinitions(
void *theEnv)
{
#if ! RUN_TIME
#if DEBUGGING_FUNCTIONS
EnvDefineFunction2(theEnv,"facts", 'v', PTIEF FactsCommand, "FactsCommand", "*4iu");
#endif
//madianyi Begin
EnvDefineFunction(theEnv,"update", 'u', PTIEF UpdateCommand, "UpdateCommand");
//madianyi End
EnvDefineFunction(theEnv,"assert", 'u', PTIEF AssertCommand, "AssertCommand");
EnvDefineFunction2(theEnv,"retract", 'v', PTIEF RetractCommand, "RetractCommand","1*z");
EnvDefineFunction2(theEnv,"assert-string", 'u', PTIEF AssertStringFunction, "AssertStringFunction", "11s");
EnvDefineFunction2(theEnv,"str-assert", 'u', PTIEF AssertStringFunction, "AssertStringFunction", "11s");
EnvDefineFunction2(theEnv,"get-fact-duplication",'b',
GetFactDuplicationCommand,"GetFactDuplicationCommand", "00");
EnvDefineFunction2(theEnv,"set-fact-duplication",'b',
SetFactDuplicationCommand,"SetFactDuplicationCommand", "11");
EnvDefineFunction2(theEnv,"save-facts", 'b', PTIEF SaveFactsCommand, "SaveFactsCommand", "1*wk");
EnvDefineFunction2(theEnv,"load-facts", 'b', PTIEF LoadFactsCommand, "LoadFactsCommand", "11k");
EnvDefineFunction2(theEnv,"fact-index", 'g', PTIEF FactIndexFunction,"FactIndexFunction", "11y");
AddFunctionParser(theEnv,"assert",AssertParse);
FuncSeqOvlFlags(theEnv,"assert",FALSE,FALSE);
#else
#if MAC_XCD
#pragma unused(theEnv)
#endif
#endif
}
globle void DeftemplateFunctions(
void *theEnv)
{
#if ! RUN_TIME
EnvDefineFunction(theEnv,"modify",'u', PTIEF ModifyCommand,"ModifyCommand");
EnvDefineFunction(theEnv,"duplicate",'u', PTIEF DuplicateCommand,"DuplicateCommand");
#if (! BLOAD_ONLY)
AddFunctionParser(theEnv,"modify",ModifyParse);
AddFunctionParser(theEnv,"duplicate",DuplicateParse);
#endif
FuncSeqOvlFlags(theEnv,"modify",FALSE,FALSE);
FuncSeqOvlFlags(theEnv,"duplicate",FALSE,FALSE);
#else
#if MAC_MCW || IBM_MCW
#pragma unused(theEnv)
#endif
#endif
}
globle void ProceduralFunctionParsers()
{
#if (! BLOAD_ONLY)
AddFunctionParser("bind",BindParse);
AddFunctionParser("progn",PrognParse);
AddFunctionParser("if",IfParse);
AddFunctionParser("while",WhileParse);
AddFunctionParser("loop-for-count",LoopForCountParse);
AddFunctionParser("return",ReturnParse);
AddFunctionParser("break",BreakParse);
AddFunctionParser("switch",SwitchParse);
#endif
}
globle void ProceduralFunctionParsers(
void *theEnv)
{
AllocateEnvironmentData(theEnv,PRCDRPSR_DATA,sizeof(struct procedureParserData),NULL);
#if (! BLOAD_ONLY)
AddFunctionParser(theEnv,"bind",BindParse);
AddFunctionParser(theEnv,"progn",PrognParse);
AddFunctionParser(theEnv,"if",IfParse);
AddFunctionParser(theEnv,"while",WhileParse);
AddFunctionParser(theEnv,"loop-for-count",LoopForCountParse);
AddFunctionParser(theEnv,"return",ReturnParse);
AddFunctionParser(theEnv,"break",BreakParse);
AddFunctionParser(theEnv,"switch",SwitchParse);
#endif
}
/****************************************************
NAME : SetupFactQuery
DESCRIPTION : Initializes fact query H/L
functions and parsers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Sets up kernel functions and parsers
NOTES : None
****************************************************/
globle void SetupFactQuery(
void *theEnv)
{
AllocateEnvironmentData(theEnv,FACT_QUERY_DATA,sizeof(struct factQueryData),NULL);
#if RUN_TIME
FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL = FindSymbolHN(theEnv,QUERY_DELIMETER_STRING);
#endif
#if ! RUN_TIME
FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL = (SYMBOL_HN *) EnvAddSymbol(theEnv,QUERY_DELIMETER_STRING);
IncrementSymbolCount(FactQueryData(theEnv)->QUERY_DELIMETER_SYMBOL);
EnvDefineFunction2(theEnv,"(query-fact)",'u',
PTIEF GetQueryFact,"GetQueryFact",NULL);
EnvDefineFunction2(theEnv,"(query-fact-slot)",'u',
PTIEF GetQueryFactSlot,"GetQueryFactSlot",NULL);
EnvDefineFunction2(theEnv,"any-factp",'b',PTIEF AnyFacts,"AnyFacts",NULL);
AddFunctionParser(theEnv,"any-factp",FactParseQueryNoAction);
EnvDefineFunction2(theEnv,"find-fact",'m',
PTIEF QueryFindFact,"QueryFindFact",NULL);
AddFunctionParser(theEnv,"find-fact",FactParseQueryNoAction);
EnvDefineFunction2(theEnv,"find-all-facts",'m',
PTIEF QueryFindAllFacts,"QueryFindAllFacts",NULL);
AddFunctionParser(theEnv,"find-all-facts",FactParseQueryNoAction);
EnvDefineFunction2(theEnv,"do-for-fact",'u',
PTIEF QueryDoForFact,"QueryDoForFact",NULL);
AddFunctionParser(theEnv,"do-for-fact",FactParseQueryAction);
EnvDefineFunction2(theEnv,"do-for-all-facts",'u',
PTIEF QueryDoForAllFacts,"QueryDoForAllFacts",NULL);
AddFunctionParser(theEnv,"do-for-all-facts",FactParseQueryAction);
EnvDefineFunction2(theEnv,"delayed-do-for-all-facts",'u',
PTIEF DelayedQueryDoForAllFacts,
"DelayedQueryDoForAllFacts",NULL);
AddFunctionParser(theEnv,"delayed-do-for-all-facts",FactParseQueryAction);
#endif
}
/****************************************************
NAME : SetupQuery
DESCRIPTION : Initializes instance query H/L
functions and parsers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Sets up kernel functions and parsers
NOTES : None
****************************************************/
globle void SetupQuery(
void *theEnv,
EXEC_STATUS)
{
AllocateEnvironmentData(theEnv,execStatus,INSTANCE_QUERY_DATA,sizeof(struct instanceQueryData),NULL);
#if ! RUN_TIME
InstanceQueryData(theEnv,execStatus)->QUERY_DELIMETER_SYMBOL = (SYMBOL_HN *) EnvAddSymbol(theEnv,execStatus,QUERY_DELIMETER_STRING);
IncrementSymbolCount(InstanceQueryData(theEnv,execStatus)->QUERY_DELIMETER_SYMBOL);
EnvDefineFunction2(theEnv,execStatus,"(query-instance)",'o',
PTIEF GetQueryInstance,"GetQueryInstance",NULL);
EnvDefineFunction2(theEnv,execStatus,"(query-instance-slot)",'u',
PTIEF GetQueryInstanceSlot,"GetQueryInstanceSlot",NULL);
EnvDefineFunction2(theEnv,execStatus,"any-instancep",'b',PTIEF AnyInstances,"AnyInstances",NULL);
AddFunctionParser(theEnv,execStatus,"any-instancep",ParseQueryNoAction);
EnvDefineFunction2(theEnv,execStatus,"find-instance",'m',
PTIEF QueryFindInstance,"QueryFindInstance",NULL);
AddFunctionParser(theEnv,execStatus,"find-instance",ParseQueryNoAction);
EnvDefineFunction2(theEnv,execStatus,"find-all-instances",'m',
PTIEF QueryFindAllInstances,"QueryFindAllInstances",NULL);
AddFunctionParser(theEnv,execStatus,"find-all-instances",ParseQueryNoAction);
EnvDefineFunction2(theEnv,execStatus,"do-for-instance",'u',
PTIEF QueryDoForInstance,"QueryDoForInstance",NULL);
AddFunctionParser(theEnv,execStatus,"do-for-instance",ParseQueryAction);
EnvDefineFunction2(theEnv,execStatus,"do-for-all-instances",'u',
PTIEF QueryDoForAllInstances,"QueryDoForAllInstances",NULL);
AddFunctionParser(theEnv,execStatus,"do-for-all-instances",ParseQueryAction);
EnvDefineFunction2(theEnv,execStatus,"delayed-do-for-all-instances",'u',
PTIEF DelayedQueryDoForAllInstances,
"DelayedQueryDoForAllInstances",NULL);
AddFunctionParser(theEnv,execStatus,"delayed-do-for-all-instances",ParseQueryAction);
#endif
}
/****************************************************
NAME : SetupFactQuery
DESCRIPTION : Initializes fact query H/L
functions and parsers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Sets up kernel functions and parsers
NOTES : None
****************************************************/
void SetupFactQuery(
Environment *theEnv)
{
AllocateEnvironmentData(theEnv,FACT_QUERY_DATA,sizeof(struct factQueryData),NULL);
#if RUN_TIME
FactQueryData(theEnv)->QUERY_DELIMITER_SYMBOL = FindSymbolHN(theEnv,QUERY_DELIMITER_STRING,SYMBOL_BIT);
#endif
#if ! RUN_TIME
FactQueryData(theEnv)->QUERY_DELIMITER_SYMBOL = CreateSymbol(theEnv,QUERY_DELIMITER_STRING);
IncrementLexemeCount(FactQueryData(theEnv)->QUERY_DELIMITER_SYMBOL);
AddUDF(theEnv,"(query-fact)","f",0,UNBOUNDED,NULL,GetQueryFact,"GetQueryFact",NULL);
AddUDF(theEnv,"(query-fact-slot)","*",0,UNBOUNDED,NULL,GetQueryFactSlot,"GetQueryFactSlot",NULL);
AddUDF(theEnv,"any-factp","b",0,UNBOUNDED,NULL,AnyFacts,"AnyFacts",NULL);
AddUDF(theEnv,"find-fact","m",0,UNBOUNDED,NULL,QueryFindFact,"QueryFindFact",NULL);
AddUDF(theEnv,"find-all-facts","m",0,UNBOUNDED,NULL,QueryFindAllFacts,"QueryFindAllFacts",NULL);
AddUDF(theEnv,"do-for-fact","*",0,UNBOUNDED,NULL,QueryDoForFact,"QueryDoForFact",NULL);
AddUDF(theEnv,"do-for-all-facts","*",0,UNBOUNDED,NULL,QueryDoForAllFacts,"QueryDoForAllFacts",NULL);
AddUDF(theEnv,"delayed-do-for-all-facts","*",0,UNBOUNDED,NULL,DelayedQueryDoForAllFacts,"DelayedQueryDoForAllFacts",NULL);
#endif
AddFunctionParser(theEnv,"any-factp",FactParseQueryNoAction);
AddFunctionParser(theEnv,"find-fact",FactParseQueryNoAction);
AddFunctionParser(theEnv,"find-all-facts",FactParseQueryNoAction);
AddFunctionParser(theEnv,"do-for-fact",FactParseQueryAction);
AddFunctionParser(theEnv,"do-for-all-facts",FactParseQueryAction);
AddFunctionParser(theEnv,"delayed-do-for-all-facts",FactParseQueryAction);
}
/****************************************************
NAME : SetupQuery
DESCRIPTION : Initializes instance query H/L
functions and parsers
INPUTS : None
RETURNS : Nothing useful
SIDE EFFECTS : Sets up kernel functions and parsers
NOTES : None
****************************************************/
globle void SetupQuery()
{
#if ! RUN_TIME
QUERY_DELIMETER_SYMBOL = (SYMBOL_HN *) AddSymbol(QUERY_DELIMETER_STRING);
IncrementSymbolCount(QUERY_DELIMETER_SYMBOL);
DefineFunction2("(query-instance)",'o',
PTIF GetQueryInstance,"GetQueryInstance",NULL);
DefineFunction2("(query-instance-slot)",'u',
PTIF GetQueryInstanceSlot,"GetQueryInstanceSlot",NULL);
DefineFunction2("any-instancep",'b',PTIF AnyInstances,"AnyInstances",NULL);
AddFunctionParser("any-instancep",ParseQueryNoAction);
DefineFunction2("find-instance",'m',
PTIF QueryFindInstance,"QueryFindInstance",NULL);
AddFunctionParser("find-instance",ParseQueryNoAction);
DefineFunction2("find-all-instances",'m',
PTIF QueryFindAllInstances,"QueryFindAllInstances",NULL);
AddFunctionParser("find-all-instances",ParseQueryNoAction);
DefineFunction2("do-for-instance",'u',
PTIF QueryDoForInstance,"QueryDoForInstance",NULL);
AddFunctionParser("do-for-instance",ParseQueryAction);
DefineFunction2("do-for-all-instances",'u',
PTIF QueryDoForAllInstances,"QueryDoForAllInstances",NULL);
AddFunctionParser("do-for-all-instances",ParseQueryAction);
DefineFunction2("delayed-do-for-all-instances",'u',
PTIF DelayedQueryDoForAllInstances,
"DelayedQueryDoForAllInstances",NULL);
AddFunctionParser("delayed-do-for-all-instances",ParseQueryAction);
#endif
}
