#include "common.h"

#ifdef INFORMATION

Facts are added as layers.You remove facts by unpeeling a layer.You can "delete" a fact merely by

marking it dead.

Layer - 1: facts resulting from wordnet dictionary(wordnetFacts)

Layer0 : facts resulting from topic system build0

Layer1 : facts resulting from topic system build1

Layer2 : facts created by user

Layer 2 is always unpeeled after an interchange with the chatbot, in preparation for a new user who may chat with a different persona.

Layers 0 and 1 are unpeeled if you want to restart the topic system to read in new topic data on the fly or rebuild 0.

Layer 1 is unpeeled for a new build 1.

Layer - 1 is never unpeeled.If you want to modify the dictionary, you either restart the chatbot entirely

or patch in data piggy backing on facts(like from the topic system).

Unpeeling a layer implies you will also reset dictionary / stringspace pointers back to levels at the

start of the layer since facts may have allocated dictionary and string items.

This is ReturnToDictionaryFreeze for unpeeling 3 / 4 and ReturnDictionaryToWordNet for unpeeling layer 2.

#endif

int worstlastFactUsed = 1000000;

char traceSubject[100];

bool allowBootKill = false;

char traceVerb[100];

char traceObject[100];

bool bootFacts = false;

bool recordBoot = false;

uint64 allowedBots = 0xffffffffffffffffULL; // default fact visibility restriction is all bots

uint64 myBot = 0; // default fact creation restriction

size_t maxFacts = MAX_FACT_NODES; // how many facts we can create at max

HEAPREF factThread = NULL;

static STACKREF stackFactThread = NULL;

bool factsExhausted = false;

FACT* factBase = NULL; // start of all facts

FACT* factEnd = NULL; // end of all facts

FACT* factsPreBuild[NUMBER_OF_LAYERS+1]; // on last fact of build0 facts, start of build1 facts

FACT* lastFactUsed = NULL; // lastFactUsed is a fact in use (increment before use as a free fact)

FACT* currentFact = NULL; // current fact found or created

// values of verbs to compare against

MEANING Mmember; // represents concept sets

MEANING Mis; // represents wordnet hierarchy

MEANING Mexclude; // represents restriction of word not allowed in set (blocking inheritance)

bool seeAllFacts = false;

FACT* Index2Fact(FACTOID e)

{

FACT* F = NULL;

if (e)

{

F = e + factBase;

if (F > lastFactUsed)

{

char buf[MAX_WORD_SIZE];

strcpy(buf, StdIntOutput(lastFactUsed - factBase));

ReportBug((char*)"Illegal fact index %d last:%s ", e, buf);

F = NULL;

}

}

return F;

}

static void VerifyField(FACT* F, MEANING field, unsigned int offset)

{

WORDP D = Meaning2Word(field);

FACTOID* x = (&D->subjectHead) + offset;

FACT* G = Index2Fact(*x);

int limit = 300000;

while (G && --limit)

{

if (G == F) return; // found it

FACTOID* y = (&G->subjectNext) + offset;

G = Index2Fact(*y);

}

if (!limit)

ReportBug("Cicular field data")

else ReportBug("Fact not woven correctly")

}

static void VerifyFact(FACT* F)

{

// prove dict entries can find this fact and that is has no loops

if (!(F->flags & FACTSUBJECT)) VerifyField(F, F->subject,0);

if (!(F->flags & FACTVERB)) VerifyField(F, F->verb,1);

if (!(F->flags & FACTOBJECT)) VerifyField(F, F->object,2);

}

void VerifyFacts()

{

FACT* F = factBase;

while (++F <= lastFactUsed)

{

VerifyFact(F);

}

}

bool UnacceptableFact(FACT* F,bool jsonavoid)

{

if (!F || F->flags & FACTDEAD) return true;

// if ownership flags exist (layer0 or layer1) and we have different ownership.

return (F->botBits && !(F->botBits & myBot) && !seeAllFacts) ? true : false;

}

FACT* GetSubjectNext(FACT* F) { return Index2Fact(F->subjectNext);}

FACT* GetVerbNext(FACT* F) {return Index2Fact(F->verbNext);}

FACT* GetObjectNext(FACT* F) {return Index2Fact(F->objectNext);}

bool ValidMemberFact(FACT* F)

{

return (F->verb == Mmember && (!myBot || !F->botBits || F->botBits & myBot));

}

FACT* GetSubjectNondeadNext(FACT* F,bool jsonaccept)

{

FACT* G = F;

while (F)

{

F = Index2Fact(F->subjectNext);

if (F && !UnacceptableFact(F,jsonaccept)) break;

}

if (F == G)

{

ReportBug("Infinite loop in GetSubjectNondeadNext ")

F = NULL;

}

return F;

}

FACT* GetVerbNondeadNext(FACT* F)

{

FACT* G = F;

while (F)

{

F = Index2Fact(F->verbNext);

if (F && !UnacceptableFact(F,true)) break;

}

if (F == G)

{

ReportBug("Infinite loop in GetVerbNondeadNext ")

F = NULL;

}

return F;

}

FACT* GetObjectNondeadNext(FACT* F)

{

FACT* G = F;

while (F)

{

F = Index2Fact(F->objectNext);

if (F && !UnacceptableFact(F,true)) break;

}

if (F == G)

{

ReportBug("Infinite loop in GetObjectNondeadNext ")

F = NULL;

}

return F;

}

FACT* GetSubjectNondeadHead(FACT* F)

{

F = Index2Fact(F->subjectHead);

while (F && UnacceptableFact(F,true))

{

F = Index2Fact(F->subjectNext);

}

return F;

}

FACT* GetVerbNondeadHead(FACT* F)

{

F = Index2Fact(F->verbHead);

while (F && UnacceptableFact(F,true))

{

F = Index2Fact(F->verbNext);

}

return F;

}

FACT* GetObjectNondeadHead(FACT* F)

{

F = Index2Fact(F->objectHead);

while (F && UnacceptableFact(F,true))

{

F = Index2Fact(F->objectNext);

}

return F;

}

FACT* GetSubjectNondeadHead(WORDP D, bool jsonaccess) // able to get special marker empty fact for json units

{

if (!D) return NULL;

FACT* F = Index2Fact(D->subjectHead);

while (F && UnacceptableFact(F,jsonaccess))

{

F = Index2Fact(F->subjectNext);

}

return F;

}

FACT* GetVerbNondeadHead(WORDP D)

{

if (!D) return NULL;

FACT* F = Index2Fact(D->verbHead);

while (F && UnacceptableFact(F,true))

{

F = Index2Fact(F->verbNext);

}

return F;

}

FACT* GetObjectNondeadHead(WORDP D)

{

if (!D) return NULL;

FACT* F = Index2Fact(D->objectHead);

while (F && UnacceptableFact(F,true))

{

F = Index2Fact(F->objectNext);

}

return F;

}

void SetSubjectNext(FACT* F, FACT* value){ F->subjectNext = Fact2Index(value);}

void SetVerbNext(FACT* F, FACT* value) {F->verbNext = Fact2Index(value);}

void SetObjectNext(FACT* F, FACT* value){ F->objectNext = Fact2Index(value);}

FACTOID Fact2Index(FACT* F)

{

return (F) ? ((FACTOID)(F - factBase)) : 0;

}

FACT* FactTextIndex2Fact(char* id) // given number word, get corresponding fact

{

char word[MAX_WORD_SIZE];

strcpy(word,id);

char* comma = word;

while ((comma = strchr(comma,','))) memmove(comma,comma+1,strlen(comma)); // maybe number has commas, like 100,000,300 . remove them

unsigned int n = atoi(word);

if (n <= 0) return NULL;

return (n <= (unsigned int)(lastFactUsed-factBase)) ? Index2Fact(n) : NULL;

}

int GetSetID(char* x)

{

if (*x != '@') return ILLEGAL_FACTSET;

if (!IsDigit(*++x)) return ILLEGAL_FACTSET;

unsigned int n = *x - '0';

if (IsDigit(*++x)) n = (n * 10) + *x - '0';

// allow additional characters naming a field

return (n > MAX_FIND_SETS) ? ILLEGAL_FACTSET : n;

}

FACT* EarliestFact(MEANING M) // earliest fact is last in list

{

FACT* F = GetSubjectNondeadHead(M); // most recent fact

FACT* G = F;

while (F)

{

F = GetSubjectNondeadHead(F);

if (F) G = F;

}

return G;

}

bool GetSetMod(char* x)

{

if (!IsDigit(*++x)) return false; // illegal set

if (IsDigit(*++x)) ++x;

if ((*x == 's' || *x == 'S' ) && strnicmp(x,(char*)"subject",7)) return false;

if ((*x == 'v' || *x == 'V' )&& strnicmp(x,(char*)"verb",4)) return false;

if ((*x == 'o' || *x == 'O' )&& strnicmp(x,(char*)"object",6)) return false;

if ((*x == 'a' || *x == 'A' )&& strnicmp(x,(char*)"all",4)) return false;

if ((*x == 'f'|| *x == 'F' ) && strnicmp(x,(char*)"fact",4)) return false;

return true;

}

char* GetSetType(char* x)

{ // @13subject returns subject

if (!x[0] || !x[1] ) return ""; // safety from bad data

x += 2;

if (IsDigit(*x)) ++x;

return x;

}

char* GetSetEnd(char* x)

{ // @adagsubject returns subject

char* start = x;

while (IsAlphaUTF8(*++x)){;} // find natural end.

size_t len = x - start; // this long

if (len >= 9 && !strnicmp(x-7,(char*)"subject",7)) x -= 7;

else if (len >= 6 && !strnicmp(x-4,(char*)"verb",4)) x -= 4;

else if (len >= 8 && !strnicmp(x-6,(char*)"object",6)) x -= 6;

else if (len >= 6 && !strnicmp(x-4,(char*)"fact",4)) x -= 4;

else if (len >= 5 && !strnicmp(x-3,(char*)"all",3)) x -= 3;

if (IsDigit(*x)) ++x;

return x;

}

void TraceFact(FACT* F,bool ignoreDead)

{

char* word = AllocateBuffer();

Log(USERLOG,"%d: %s\r\n",Fact2Index(F),WriteFact(F,false,word,ignoreDead,false,true));

Log(USERLOG,"");

FreeBuffer();

}

void ClearUserFacts()

{

for (int i = 0; i <= MAX_FIND_SETS; ++i) SET_FACTSET_COUNT(i, 0);

while (lastFactUsed > factLocked) FreeFact(lastFactUsed--); // erase new facts

}

void InitFacts()

{

*traceSubject = 0;

*traceVerb = 0;

*traceObject = 0;

if ( factBase == 0)

{

factBase = (FACT*) malloc(maxFacts * sizeof(FACT)); // only on 1st startup, not on reload

if ( factBase == 0)

{

(*printer)((char*)"%s",(char*)"failed to allocate fact space\r\n");

myexit((char*)"FATAL failed to get fact space");

}

}

memset(factBase,0,sizeof(FACT) * maxFacts); // not strictly necessary

lastFactUsed = factBase; // 1st fact is always meaningless

factEnd = factBase + maxFacts;

}

void InitFactWords()

{

// special internal fact markers (always 1st 3 words)

Mmember = MakeMeaning(StoreWord((char*)"member",AS_IS));

Mexclude = MakeMeaning(StoreWord((char*)"exclude", AS_IS));

Mis = MakeMeaning(StoreWord((char*)"is", AS_IS));

}

void CloseFacts()

{

free(factBase);

factBase = 0;

}

void FreeFact(FACT* F)

{ // most recent facts are always at the top of any xref list. Can only free facts sequentially backwards.

if (!F) return;

if (!F->subject) // unindexed fact recording a fact delete that must be undeleted

{

if (!F->object) // death of fact fact (verb but no object)

{

F = Index2Fact(F->verb);

F->flags &= -1 ^ FACTDEAD;

}

else if (F->flags & ITERATOR_FACT) {;} // holds iterator backtrack

else // undo a variable assignment fact (verb and object)

{

WORDP D = Meaning2Word(F->verb); // the variable

unsigned int offset = (unsigned int) F->object;

D->w.userValue = (offset == 1) ? NULL : (heapBase + offset);

}

}

else // normal indexed fact

{

if (!(F->flags & FACTSUBJECT)) SetSubjectHead(F->subject,GetSubjectNext(F)); // dont use nondead

else SetSubjectHead(Index2Fact(F->subject),GetSubjectNext(F)); // dont use nondead

if (!(F->flags & FACTVERB)) SetVerbHead(F->verb,GetVerbNext(F)); // dont use nondead

else SetVerbHead(Index2Fact(F->verb),GetVerbNext(F)); // dont use nondead

if (!(F->flags & FACTOBJECT)) SetObjectHead(F->object,GetObjectNext(F)); // dont use nondead

else SetObjectHead(Index2Fact(F->object),GetObjectNext(F)); // dont use nondead

}

}

unsigned int AddFact(unsigned int set, FACT* F) // fact added to factset

{

unsigned int count = FACTSET_COUNT(set);

if (++count > MAX_FIND) --count;

factSet[set][count] = F;

SET_FACTSET_COUNT(set,count);

return count;

}

FACT* SpecialFact(FACTOID_OR_MEANING verb, FACTOID_OR_MEANING object,unsigned int flags)

{

// allocate a fact

if (++lastFactUsed == factEnd)

{

--lastFactUsed;

if (loading || compiling) ReportBug((char*)"FATAL: out of fact space at %d", Fact2Index(lastFactUsed))

ReportBug((char*)"FATAL: out of fact space at %d",Fact2Index(lastFactUsed))

(*printer)((char*)"%s",(char*)"out of fact space");

return lastFactUsed; // dont return null because we dont want to crash anywhere

}

// init the basics

memset(lastFactUsed,0,sizeof(FACT));

lastFactUsed->verb = verb;

lastFactUsed->object = object;

lastFactUsed->flags = FACTTRANSIENT | FACTDEAD | flags; // cannot be written or kept

return lastFactUsed;

}

static void ReleaseDictWord(WORDP D,WORDP dictbase)

{

char c = *D->word;

// dont erase interally used words

if (c == '$' || c == '~' || c == '^' || c == '%' || c == '#') return;

if (D >= dictbase) // we dont have to protect this

{

if (!(D->internalBits & BEEN_HERE) && !GetSubjectNondeadHead(D))

{

D->word = " "; // kill off its name

}

}

}

static void MarkDictWord(WORDP D, WORDP dictbase)

{ // insure this word is safe from destruction

if (D >= dictbase)

D->internalBits |= BEEN_HERE;

}

void RipFacts(FACT* F,WORDP dictBase)

{

FACT* base = lastFactUsed++;

while (--lastFactUsed > F) // mark all still used new dict words

{

if (!(F->flags & FACTDEAD))

{

MarkDictWord(Meaning2Word(lastFactUsed->subject), dictBase);

MarkDictWord(Meaning2Word(lastFactUsed->verb), dictBase);

MarkDictWord(Meaning2Word(lastFactUsed->object), dictBase);

}

}

lastFactUsed = base + 1;

while (--lastFactUsed > F)

{

FreeFact(lastFactUsed); // remove all links from dict

if (F->flags & FACTDEAD) // release

{

ReleaseDictWord(Meaning2Word(lastFactUsed->subject), dictBase);

ReleaseDictWord(Meaning2Word(lastFactUsed->verb), dictBase);

ReleaseDictWord(Meaning2Word(lastFactUsed->object), dictBase);

}

}

lastFactUsed = base;

}

FACT* WeaveFact(FACT* current)

{

if (current->subject == 0) return current; // dummy fact

unsigned int properties = current->flags;

FACT* F;

WORDP s = (properties & FACTSUBJECT) ? NULL : Meaning2Word(current->subject);

WORDP v = (properties & FACTVERB) ? NULL : Meaning2Word(current->verb);

WORDP o = (properties & FACTOBJECT) ? NULL : Meaning2Word(current->object);

// crossreference

if (s)

{

SetSubjectNext(current, GetSubjectHead(current->subject)); // dont use nondead

SetSubjectHead(current->subject, current);

}

else

{

F = Index2Fact(current->subject);

if (F)

{

SetSubjectNext(current, GetSubjectHead(F)); // dont use nondead

SetSubjectHead(F, current);

}

else return NULL;

}

if (v)

{

SetVerbNext(current, GetVerbHead(current->verb)); // dont use nondead

SetVerbHead(current->verb, current);

}

else

{

F = Index2Fact(current->verb);

if (F)

{

SetVerbNext(current, GetVerbHead(F)); // dont use nondead

SetVerbHead(F, current);

}

else return NULL;

}

if (o)

{

SetObjectNext(current, GetObjectHead(current->object)); // dont use nondead

SetObjectHead(current->object, current);

}

else

{

F = Index2Fact(current->object);

if (F)

{

SetObjectNext(current, GetObjectNext(F)); // dont use nondead

SetObjectHead(F, current);

}

else return NULL;

}

return current;

}

void UnweaveFactSubject(FACT* F)

{

FACT* listHead = DeleteFromList(GetSubjectHead(F->subject), F, GetSubjectNext, SetSubjectNext); // dont use nondead

SetSubjectHead(F->subject, listHead); // removed from dict element

}

void UnweaveFactVerb(FACT* F)

{

FACT* listHead = DeleteFromList(GetVerbHead(F->verb), F, GetVerbNext, SetVerbNext); // dont use nondead

SetVerbHead(F->verb, listHead); // removed from dict element

}

void UnweaveFactObject(FACT* F)

{

FACT* listHead = DeleteFromList(GetObjectHead(F->object), F, GetObjectNext, SetObjectNext); // dont use nondead

SetObjectHead(F->object, listHead); // removed from dict element

}

void UnweaveFact(FACT* F)

{// decouple fact from dictionary links to it

if (F->subject) UnweaveFactSubject(F);

if (F->verb) UnweaveFactVerb(F);

if (F->object) UnweaveFactObject(F);

}

void WeaveFacts(FACT* F)

{

--F;

while (++F <= lastFactUsed) WeaveFact(F);

}

void AutoKillFact(MEANING M)

{

int id = atoi(Meaning2Word(M)->word);

KillFact(Index2Fact(id));

}

void KillFact(FACT* F,bool jsonrecurse, bool autoreviseArray)

{

if (!F || F->flags & FACTDEAD) return; // already dead

if (F <= factsPreBuild[currentBeforeLayer] && !allowBootKill)

return; // may not kill off facts built into world

F->flags |= FACTDEAD;

if (trace & TRACE_FACT && CheckTopicTrace())

{

Log(USERLOG,"Kill: ");

TraceFact(F);

}

if (F->flags & FACTAUTODELETE)

{

if (F->flags & FACTSUBJECT) AutoKillFact(F->subject);

if (F->flags & FACTVERB) AutoKillFact(F->verb);

if (F->flags & FACTOBJECT) AutoKillFact(F->object);

}

// recurse on JSON datastructures below if they are being deleted on right side

if (F->flags & (JSON_ARRAY_VALUE | JSON_OBJECT_VALUE) && jsonrecurse)

{

WORDP jsonarray = Meaning2Word(F->object);

// should it recurse to kill guy refered to?

// if no other living fact refers to it, you can also kill the referred object/array

FACT* H = GetObjectNondeadHead(jsonarray); // facts which link to this

if (!H) jkillfact(jsonarray);

}

if (autoreviseArray && F->flags & JSON_ARRAY_FACT) JsonRenumber(F);// have to renumber this array

if (planning) SpecialFact(Fact2Index(F),0,0); // save to restore

// if this fact has facts depending on it, they too must die

FACT* G = GetSubjectNondeadHead(F);

while (G)

{

KillFact(G);

G = GetSubjectNondeadNext(G);

}

G = GetVerbNondeadHead(F);

while (G)

{

KillFact(G);

G = GetVerbNondeadNext(G);

}

G = GetObjectNondeadHead(F);

while (G)

{

KillFact(G);

G = GetObjectNondeadNext(G);

}

}

void ResetFactSystem(FACT* locked)

{

while (lastFactUsed > locked) FreeFact(lastFactUsed--); // restore to end of basic facts

for (unsigned int i = 0; i <= MAX_FIND_SETS; ++i) // clear any factset with contaminated data

{

unsigned int limit = FACTSET_COUNT(i);

for (unsigned int k = 1; k <= limit; ++k)

{

if (factSet[i][k] > locked)

{

SET_FACTSET_COUNT(i, 0); // empty all facts since set is contaminated

break;

}

}

}

}

FACT* FindFact(FACTOID_OR_MEANING subject, FACTOID_OR_MEANING verb, FACTOID_OR_MEANING object, unsigned int properties)

{

FACT* F;

FACT* G;

if (!subject || !verb || !object) return NULL;

if (properties & FACTDUPLICATE)

return NULL; // can never find this since we are allowed to duplicate and we do NOT want to share any existing fact

// see if fact already exists. if so, just return it

if (properties & FACTSUBJECT)

{

F = Index2Fact(subject);

G = GetSubjectNondeadHead(F);

while (G)

{

if (G->verb == verb && G->object == object && G->flags == properties && G->botBits == myBot && !(G->flags & FACTDEAD)) return G;

G = GetSubjectNondeadNext(G);

}

return NULL;

}

else if (properties & FACTVERB)

{

F = Index2Fact(verb);

G = GetVerbNondeadHead(F);

while (G)

{

if (G->subject == subject && G->object == object && G->flags == properties && G->botBits == myBot && !(G->flags & FACTDEAD)) return G;

G = GetVerbNondeadNext(G);

}

return NULL;

}

else if (properties & FACTOBJECT)

{

F = Index2Fact(object);

G = GetObjectNondeadHead(F);

while (G)

{

if (G->subject == subject && G->verb == verb && G->flags == properties && G->botBits == myBot && !(G->flags & FACTDEAD)) return G;

G = GetObjectNondeadNext(G);

}

return NULL;

}

// simple FACT* based on dictionary entries

F = GetSubjectNondeadHead(Meaning2Word(subject));

while (F)

{

if ( F->subject == subject && F->verb == verb && F->object == object && properties == F->flags && F->botBits == myBot && !(F->flags & FACTDEAD)) return F;

F = GetSubjectNondeadNext(F);

}

return NULL;

}

FACT* CreateFact(FACTOID_OR_MEANING subject, FACTOID_OR_MEANING verb, FACTOID_OR_MEANING object, unsigned int properties)

{

currentFact = NULL;

if (!subject || !object || !verb)

{

if (!subject)

ReportBug((char*)"Missing subject field in fact create at line %d of %s",currentFileLine,currentFilename)

if (!verb)

ReportBug((char*)"Missing verb field in fact create at line %d of %s",currentFileLine,currentFilename)

if (!object)

ReportBug((char*)"Missing object field in fact create at line %d of %s",currentFileLine,currentFilename)

return NULL;

}

// get correct field values

WORDP s = (properties & FACTSUBJECT) ? NULL : Meaning2Word(subject);

WORDP v = (properties & FACTVERB) ? NULL : Meaning2Word(verb);

WORDP o = (properties & FACTOBJECT) ? NULL : Meaning2Word(object);

if (s && !s->word)

{

ReportBug((char*)"bad choice in fact subject")

return NULL;

}

if (v && !v->word)

{

ReportBug((char*)"bad choice in fact verb")

return NULL;

}

if (o && !o->word)

{

ReportBug((char*)"bad choice in fact object")

return NULL;

}

// convert any restricted meaning

MEANING other;

char* word;

if (s && (word = s->word) && *word != '"' && strchr(word+1,'~')) // has number or word after it? convert notation

{

other = ReadMeaning(word,true,true);

if (Meaning2Word(other) == s) {;}

else if (Meaning2Index(other) || GETTYPERESTRICTION(other)) subject = other;

}

if (v && (word = v->word) && strchr(word+1,'~')) // has number or word after it? convert notation

{

other = ReadMeaning(word,true,true);

if (Meaning2Word(other) == v) {;}

else if (Meaning2Index(other) || GETTYPERESTRICTION(other)) verb = other;

}

if (o && (word = o->word) && strchr(word+1,'~')) // has number or word after it? convert notation

{

other = ReadMeaning(word,true,true);

if (Meaning2Word(other) == o) {;}

else if (Meaning2Index(other) || GETTYPERESTRICTION(other)) object = other;

}

if (*traceSubject)

{

if (s && !stricmp(s->word,traceSubject) && *traceVerb && *traceObject)

{

DebugCode(NULL);

}

else if (s && !stricmp(s->word,traceSubject) && v && !stricmp(s->word,traceVerb) && *traceObject)

{

DebugCode(NULL);

}

else if (s && !stricmp(s->word,traceSubject) && o && !stricmp(s->word,traceObject) && *traceVerb)

{

DebugCode(NULL);

}

else if (s && !stricmp(s->word,traceSubject) && v && !stricmp(s->word,traceVerb) && o && !stricmp(s->word,traceObject))

{

DebugCode(NULL);

}

}

if (*traceVerb)

{

if (v && !stricmp(v->word,traceVerb) && *traceSubject && *traceObject)

{

DebugCode(NULL);

}

else if (v && !stricmp(s->word,traceVerb) && *traceSubject && o && !stricmp(s->word,traceObject))

{

DebugCode(NULL);

}

}

if (*traceObject)

{

if (o && !stricmp(o->word,traceObject) && *traceSubject && *traceVerb)

{

DebugCode(NULL);

}

}

if (compiling)

{

if (buildId == BUILD1) properties |= FACTBUILD1;

}

// insure fact is unique if requested

currentFact = (properties & FACTDUPLICATE) ? NULL : FindFact(subject,verb,object,properties);

if (trace & TRACE_FACT && currentFact && CheckTopicTrace()) Log(USERLOG," Found %d ", Fact2Index(currentFact));

if (currentFact) return currentFact;

currentFact = CreateFastFact(subject,verb,object,properties);

if (trace & TRACE_FACT && currentFact && CheckTopicTrace())

{

TraceFact(currentFact, false); // precise trace for JSON

Log(FORCESTAYUSERLOG,(char*)" Fact# %d\r\n", Fact2Index(currentFact));

}

return currentFact;

}

bool ExportFacts(char* name, int set,char* append)

{

if (set < 0 || set > MAX_FIND_SETS) return false;

if ( *name == '"')

{

++name;

size_t len = strlen(name);

if (name[len-1] == '"') name[len-1] = 0;

}

char* buffer = GetFreeCache();

char* base = buffer;

char* limit;

char* word = InfiniteStack(limit,"ExportFacts"); //short term

unsigned int count = FACTSET_COUNT(set);

for (unsigned int i = 1; i <= count; ++i)

{

FACT* F = factSet[set][i];

if (!F) strcpy(buffer,(char*)"null ");

else if ( !(F->flags & FACTDEAD))

{

unsigned int original = F->flags;

F->flags &= -1 ^ FACTTRANSIENT; // dont pass transient flag out

strcpy(buffer,WriteFact(F,false,word,false,true));

F->flags = original;

}

buffer += strlen(buffer);

}

ReleaseInfiniteStack();

FILE* out;

if (strstr(name,"ltm")) out = userFileSystem.userCreate(name); // user ltm file

else out = (append && !stricmp(append,"append")) ? FopenUTF8WriteAppend(name) : FopenUTF8Write(name);

if (out)

{

if (strstr(name,"ltm"))

{

EncryptableFileWrite(base,1,(buffer-base),out,ltmEncrypt,"LTM");

userFileSystem.userClose(out);

}

else

{

fprintf(out,(char*)"%s",base);

fclose(out);

}

}

FreeUserCache();

return (out) ? true : false;

}

static char* ExportJson1(char* jsonitem, char* buffer)

{

if (!*jsonitem)

{

strcpy(buffer,(char*)"null\r\n");

return buffer + strlen(buffer);

}

WORDP D = FindWord(jsonitem);

if (!D) return buffer;

FACT* F = GetSubjectNondeadHead(D);

while (F)

{

if ( !(F->flags & FACTDEAD))

{

unsigned int original = F->flags;

F->flags &= -1 ^ FACTTRANSIENT; // dont pass transient flag out

WriteFact(F,false,buffer,false,true);

buffer += strlen(buffer);

F->flags = original;

}

if (F->flags & (JSON_ARRAY_VALUE|JSON_OBJECT_VALUE)) buffer = ExportJson1(Meaning2Word(F->object)->word,buffer); // on object side of triple

F = GetSubjectNondeadNext(F);

}

return buffer + strlen(buffer);

}

FunctionResult ExportJson(char* name, char* jsonitem, char* append)

{

WORDP D;

if (*jsonitem)

{

D = FindWord(jsonitem);

if (!D) return FAILRULE_BIT;

}

if ( *name == '"')

{

++name;

size_t len = strlen(name);

if (name[len-1] == '"') name[len-1] = 0;

}

FILE* out;

if (strstr(name,"ltm")) out = userFileSystem.userCreate(name); // user ltm file

else out = (append && !stricmp(append,"append")) ? FopenUTF8WriteAppend(name) : FopenUTF8Write(name);

if (!out) return FAILRULE_BIT;

char* buffer = GetFreeCache(); // filesize limit

ExportJson1(jsonitem, buffer);

bool isWriteFailure = false;

if (strstr(name,"ltm"))

{

size_t wrote = EncryptableFileWrite(buffer,1,strlen(buffer),out,ltmEncrypt,"LTM");

userFileSystem.userClose(out);

if (!wrote) isWriteFailure = true;

}

else

{

fprintf(out,(char*)"%s",buffer);

fclose(out);

}

FreeUserCache();

return (isWriteFailure ? FAILRULE_BIT : NOPROBLEM_BIT);

}

char* EatFact(char* ptr,char* buffer,unsigned int flags,bool attribute)

{

ptr = SkipWhitespace(ptr); // could be user-formateed, dont trust

FunctionResult result = NOPROBLEM_BIT;

// subject

if (*ptr == '(') // nested fact

{

ptr = EatFact(ptr+1,buffer); // returns after the closing paren

flags |= FACTSUBJECT;

sprintf(buffer,(char*)"%u",currentFactIndex() ); // created OR e found instead of created

}

else ptr = GetCommandArg(ptr,buffer,result,OUTPUT_FACTREAD); // subject

ptr = SkipWhitespace(ptr); // could be user-formateed, dont trust

if (!ptr) return NULL;

if (result & ENDCODES) return ptr;

if (!*buffer)

{

if (compiling)

BADSCRIPT((char*)"FACT-1 Missing subject for fact create")

char* end = strchr(ptr,')');

return (end) ? (end + 2) : ptr;

}

char* word = AllocateStack(buffer);

*buffer = 0;

//verb

if (*ptr == '(') // nested fact

{

ptr = EatFact(ptr+1,buffer);

flags |= FACTVERB;

sprintf(buffer,(char*)"%u",currentFactIndex() );

}

else ptr = GetCommandArg(ptr,buffer,result,OUTPUT_FACTREAD); //verb

if (!ptr)

{

ReleaseStack(word);

return NULL;

}

ptr = SkipWhitespace(ptr); // could be user-formateed, dont trust

if (result & ENDCODES)

{

ReleaseStack(word);

return ptr;

}

if (!*buffer)

{

ReleaseStack(word);

if (!ptr) return NULL;

if (compiling) BADSCRIPT((char*)"FACT-2 Missing verb for fact create")

char* end = strchr(ptr,')');

return (end) ? (end + 2) : ptr;

}

char* word1 = AllocateStack(buffer);

*buffer = 0;

// object

if (*ptr == '(') // nested fact

{

ptr = EatFact(ptr+1,buffer);

flags |= FACTOBJECT;

sprintf(buffer,(char*)"%u",currentFactIndex() );

}

else ptr = GetCommandArg(ptr,buffer,result,OUTPUT_FACTREAD);

ptr = SkipWhitespace(ptr); // could be user-formateed, dont trust

if (result & ENDCODES)

{

ReleaseStack(word);

return ptr;

}

if (!*buffer)

{

ReleaseStack(word);

if (compiling) BADSCRIPT((char*)"FACT-3 Missing object for fact create - %s",readBuffer)

if (!ptr) return NULL;

char* end = strchr(ptr,')');

return (end) ? (end + 2) : ptr;

}

char* word2 = AllocateStack(buffer);

*buffer = 0;

uint64 fullflags;

bool bad = false;

bool response = false;

char strip[MAX_WORD_SIZE];

char* at = ReadCompiledWord(ptr,strip);

bool stripquote = false;

if (!strnicmp(strip,(char*)"STRIP_QUOTE",11))

{

stripquote = true;

ptr = at;

}

ptr = ReadFlags(ptr,fullflags,bad,response);