#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

static bool blockshow = false;

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

static bool verifyFacts = false;

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;

}

return F;

}

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

}

static void VerifyFact(FACT* F)

}

void C_Fact(char* word)

}

void VerifyFacts()

}

bool showit = false;

bool AcceptableFact(FACT* F)

}

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

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

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

FACT* GetSubjectNondeadNext(FACT* F)

{

FACT* G = F;

while (F)

{

F = Index2Fact(F->subjectNext);

if (F && AcceptableFact(F))

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 && AcceptableFact(F))

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 && AcceptableFact(F))

break;

}

if (F == G)

{

ReportBug("Infinite loop in GetObjectNondeadNext ");

F = NULL;

}

return F;

}

FACT* GetSubjectNondeadHead(FACT* F)

{

F = Index2Fact(F->subjectHead);

while (F)

{

if (AcceptableFact(F)) break;

F = Index2Fact(F->subjectNext);

}

return F;

}

FACT* GetVerbNondeadHead(FACT* F)

{

F = Index2Fact(F->verbHead);

while (F )

{

if (AcceptableFact(F)) break;

F = Index2Fact(F->verbNext);

}

return F;

}

FACT* GetObjectNondeadHead(FACT* F)

{

F = Index2Fact(F->objectHead);

while (F )

{

if (AcceptableFact(F)) break;

F = Index2Fact(F->objectNext);

}

return F;

}

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

{

if (!D) return NULL;

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

while (F)

{

if (AcceptableFact(F)) break;

F = Index2Fact(F->subjectNext);

}

return F;

}

FACT* GetVerbNondeadHead(WORDP D)

{

if (!D) return NULL;

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

while (F )

{

if (AcceptableFact(F)) break;

F = Index2Fact(F->verbNext);

}

return F;

}

FACT* GetObjectNondeadHead(WORDP D)

{

if (!D) return NULL;

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

while (F)

{

if (AcceptableFact(F)) break;

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)

}

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

{

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

FACT* G = F;

while (F)

{

F = GetObjectNondeadNext(F);

if (F) G = F;

}

return G;

}

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

{

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

FACT* G = F;

while (F)

{

F = GetSubjectNondeadNext(F);

if (F) G = F;

}

return G;

}

bool GetSetMod(char* x)

}

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)

}

void ClearUserFacts()

}

void InitFacts()

}

void InitFactWords()

}

void CloseFacts()

}

void FreeFact(FACT* F)

}

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

}

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)

}

static void MarkDictWord(WORDP D, WORDP dictbase)

}

void RipFacts(FACT* F,WORDP dictBase)

}

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)

}

void UnweaveFactVerb(FACT* F)

}

void UnweaveFactObject(FACT* F)

}

void UnweaveFact(FACT* F)

}

void WeaveFacts(FACT* F)

}

void AutoKillFact(MEANING M)

}

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

}

void ResetFactSystem(FACT* locked)

}

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

{

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

unsigned int wantlanguage = properties & (-1 ^ FACTLANGUAGEBITS); // implied by the actual fields

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

if (properties & FACTSUBJECT)

{

F = Index2Fact(subject);

G = GetSubjectHead(F);

while (G)

{

bool allowedBot;

if (!bot || !G->botBits) allowedBot = true; // either bot or fact is universal

else allowedBot = (G->botBits == bot);

bool allowedLanguage;

unsigned int language = G->flags & (-1 ^ FACTLANGUAGEBITS);

if (!language || !wantlanguage) allowedLanguage = true; // bot or desire is universal

else allowedLanguage = (wantlanguage == language);

if (G->verb == verb && G->object == object &&

allowedLanguage && allowedBot && !(G->flags & FACTDEAD)) return G;

G = GetSubjectNext(G);

}

return NULL;

}

else if (properties & FACTVERB)

{

F = Index2Fact(verb);

G = GetVerbHead(F);

while (G)

{

bool allowedBot;

if (!bot || !G->botBits) allowedBot = true; // either bot or fact is universal

else allowedBot = (G->botBits == bot);

bool allowedLanguage;

unsigned int language = G->flags & (-1 ^ FACTLANGUAGEBITS);

if (!language || !wantlanguage) allowedLanguage = true; // bot or desire is universal

else allowedLanguage = (wantlanguage == language);

if (G->subject == subject && G->object == object &&

allowedLanguage && allowedBot && !(G->flags & FACTDEAD)) return G;

G = GetVerbNext(G);

}

return NULL;

}

else if (properties & FACTOBJECT)

{

F = Index2Fact(object);

G = GetObjectHead(F);

while (G)

{

bool allowedBot;

if (!bot || !G->botBits) allowedBot = true; // either bot or fact is universal

else allowedBot = (G->botBits == bot);

bool allowedLanguage;

unsigned int language = G->flags & (-1 ^ FACTLANGUAGEBITS);

if (!language || !wantlanguage) allowedLanguage = true; // bot or desire is universal

else allowedLanguage = (wantlanguage == language);

if (G->subject == subject && G->verb == verb &&

allowedBot && allowedLanguage && !(G->flags & FACTDEAD)) return G;

G = GetObjectNext(G);

}

return NULL;

}

// simple FACT* based on dictionary entries

F = GetSubjectHead(Meaning2Word(subject));

while (F)

{

bool allowedBot;

if (!bot || !F->botBits) allowedBot = true; // either bot or fact is universal

else allowedBot = (F->botBits == bot);

bool allowedLanguage;

unsigned int language = F->flags & (-1 ^ FACTLANGUAGEBITS);

if (!language || !wantlanguage) allowedLanguage = true; // bot or desire is universal

else allowedLanguage = (wantlanguage == language);

if ( F->subject == subject && F->verb == verb && F->object == object &&

allowedBot && allowedLanguage && !(F->flags & FACTDEAD))

return F;

F = GetSubjectNext(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 = nullptr;

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, myBot);

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

if (currentFact) return currentFact;

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

currentFact->flags |= GetFullFactLanguage(currentFact);

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

{

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

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

}

if (verifyFacts)

{

VerifyFact(currentFact);

}

return currentFact;

}

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