#include "common.h"

#define MAX_NO_ERASE 300

#define MAX_REPEATABLE 300

#define TOPIC_LIMIT 10000

#define NEW_KEY 0x80000000

bool hypotheticalMatch = false;

int currentBeforeLayer = 0;

int hasFundamentalMeanings = 0;

bool noteRulesMatching = false;

HEAPREF rulematches = NULL;

WORDP keywordBase = NULL;

WORDP* preexistingwords = NULL;

bool monitorChange = false;

char* textBase = NULL;

unsigned int numberOfTopics = 0;

unsigned int numberOfTopicsInLayer[NUMBER_OF_LAYERS+1];

topicBlock* topicBlockPtrs[NUMBER_OF_LAYERS+1];

bool norejoinder = false;

HEAPREF unwindUserLayer = NULL;

bool shared = false;

bool loading = false;

#define MAX_OVERLAPS 1000

static WORDP overlaps[MAX_OVERLAPS];

static int overlapCount = 0;

static bool cstopicsystem = false;

static int oldNumberOfTopics; // for creating/restoring dynamic topics

int currentTopicID = 0; // current topic id

char* currentRule = 0; // current rule being procesed

int currentRuleID = -1; // current rule id

int currentReuseID = -1; // local invoking reuse

int currentReuseTopic = -1; // topic invoking reuse

int currentRuleTopic = -1;

unsigned short topicContext[MAX_RECENT + 1];

char labelContext[100][MAX_RECENT+ 1];

int inputContext[MAX_RECENT+ 1];

unsigned int contextIndex = 0;

static bool contextResult = false;

bool ruleErased = false;

#define MAX_DISABLE_TRACK 100

static char disableList[MAX_DISABLE_TRACK][200];

static unsigned int disableIndex = 0;

int sampleRule = 0;

int sampleTopic = 0;

char timeStamp[NUMBER_OF_LAYERS][20]; // when build0 was compiled

char compileVersion[NUMBER_OF_LAYERS][20]; // which CS compiled build0

char numberTimeStamp[NUMBER_OF_LAYERS][20]; // when build0 was compiled

char buildStamp[NUMBER_OF_LAYERS][150]; // compile command name of build

int outputRejoinderRuleID = NO_REJOINDER;

int outputRejoinderTopic = NO_REJOINDER;

int inputRejoinderTopic = NO_REJOINDER; // what topic were we in, that we should check for update

int inputRejoinderRuleID = NO_REJOINDER;

char* howTopic = "";

static char* keepSet[MAX_NO_ERASE]; // rules not authorized to erase themselves

static unsigned int keepIndex;

static char* repeatableSet[MAX_REPEATABLE]; // rules allowed to repeat output

static unsigned int repeatableIndex;

int topicIndex = 0;

int topicStack[MAX_TOPIC_STACK+1];

int pendingTopicIndex = 0;

int pendingTopicList[MAX_TOPIC_STACK+1];

int originalPendingTopicList[MAX_TOPIC_STACK+1];

int originalPendingTopicIndex = 0;

bool stats = false; // show how many rules were executed

unsigned int ruleCount = 0; // how many rules were executed

unsigned int xrefCount = 0; // how many xrefs were created

unsigned int duplicateCount = 0; // detecting multiple topics with same name

static unsigned char code[] = {// value to letter 0-78 (do not use - since topic system cares about it) see uncode

'0','1','2','3','4','5','6','7','8','9', // do not use / or " or \ since JSON doesnt like

'a','b','c','d','e','f','g','h','i','j',

'k','l','m','n','o','p','q','r','s','t',

'u','v','w','x','y','z','A','B','C','D',

'E','F','G','H','I','J','K','L','M','N',

'O','P','Q','R','S','T','U','V','W','X',

'Y','Z','~','!','@','#','$','%','^','&',

'*','?','-','+','=', '<','>',',','.',

};

static unsigned char uncode[] = {// letter to value - see code[]

0,0,0,0,0,0,0,0,0,0, // 0

0,0,0,0,0,0,0,0,0,0, // 10

0,0,0,0,0,0,0,0,0,0, // 20

0,0,0,63,0,65,66,67,69,0, // 30 33=! (63) 35=# (65) 36=$ (66) 37=% (67) 38=& (69)

0,0,70,73,77,72,78,0,0,1, // 40 42=* (70) 43=+ (73) 44=, (77) 45=- (72) 46=. (78) 0-9 = 0-9

2,3,4,5,6,7,8,9,0,0, // 50

75,74,76,71,64,36,37,38,39,40, // 60 60=< (75) 61== (74) 62=> (76) 63=? (71) 64=@ 65=A-Z (36-61)

41,42,43,44,45,46,47,48,49,50, // 70

51,52,53,54,55,56,57,58,59,60, // 80

61,0,0,0,68,0,0,10,11,12, // 90 90=Z 94=^ (68) 97=a-z (10-35)

13,14,15,16,17,18,19,20,21,22, // 100

23,24,25,26,27,28,29,30,31,32, // 110

33,34,35,0,0,0,62,0,0,0, // 120 122=z 126=~ (62)

};

void CleanOutput(char* word)

}

char* GetRuleIDFromText(char* ptr, int & id) // passed ptr to or before dot, returns ptr after dot on rejoinder

{

if (!ptr) return NULL;

id = -1;

char* dot = strchr(ptr,'.'); // align to dot before top level id

if (!dot) return NULL;

id = atoi(dot+1); // top level id

dot = strchr(dot+2,'.');

if (dot)

{

id |= MAKE_REJOINDERID(atoi(dot+1)); // rejoinder id

while (*++dot && IsDigit(*dot)){;} // point after it to next dot or nothing - will be =label or .tag

}

return dot;

}

void DummyEncode(char* &data) // script compiler users to reserve space for encode

}

bool DifferentTopicContext(int depthadjust, int topicid)

}

void Encode(unsigned int val,char* &ptr,int size)

}

unsigned int Decode(char* data,int size)

}

char* FullEncode(uint64 val,char* ptr) // writes least significant digits first

{ // digits are base 75

int digit1 = val % USED_CODES;

*ptr++ = code[digit1];

val = val - digit1;

val /= USED_CODES;

while (val)

{

digit1 = val % USED_CODES;

*ptr++ = code[digit1];

val = val - digit1;

val /= USED_CODES;

}

*ptr++ = ' ';

*ptr = 0;

return ptr;

}

uint64 FullDecode(char* data) // read end to front

}

void TraceSample(unsigned int topicid, unsigned int ruleID,unsigned int how)

}

char* GetTopicFile(int topicid)

{

topicBlock* block = TI(topicid);

return block->topicSourceFileName;

}

char* RuleBefore(int topicid,char* rule)

{

char* start = GetTopicData(topicid);

if (rule == start) return NULL;

rule -= 7; // jump before end marker of prior rule

while (--rule > start && *rule != ENDUNIT); // back up past start of prior rule

return (rule == start) ? rule : (rule + 5);

}

static unsigned int ByteCount (unsigned char n)

}

int TopicUsedCount(int topicid)

}

char* DisplayTopicFlags(int topicid)

{

static char buffer[MAX_WORD_SIZE];

*buffer = 0;

unsigned int flags = GetTopicFlags(topicid);

if (flags) strcat(buffer,(char*)"Flags: ");

if (flags & TOPIC_SYSTEM) strcat(buffer,(char*)"SYSTEM ");

if (flags & TOPIC_KEEP) strcat(buffer,(char*)"KEEP ");

if (flags & TOPIC_REPEAT) strcat(buffer,(char*)"REPEAT ");

if (flags & TOPIC_RANDOM) strcat(buffer,(char*)"RANDOM ");

if (flags & TOPIC_NOSTAY) strcat(buffer,(char*)"NOSTAY ");

if (flags & TOPIC_PRIORITY) strcat(buffer,(char*)"PRIORITY ");

if (flags & TOPIC_LOWPRIORITY) strcat(buffer,(char*)"LOWPRIORITY ");

if (flags & TOPIC_NOBLOCKING) strcat(buffer,(char*)"NOBLOCKING ");

if (flags & TOPIC_NOSAMPLES) strcat(buffer,(char*)"NOSAMPLES ");

if (flags & TOPIC_NOPATTERNS) strcat(buffer,(char*)"NOPATTERNS ");

if (flags & TOPIC_NOGAMBITS) strcat(buffer,(char*)"NOGAMBITS ");

if (flags & TOPIC_NOKEYS) strcat(buffer,(char*)"NOKEYS ");

if (flags & TOPIC_BLOCKED) strcat(buffer,(char*)"BLOCKED ");

if (flags & TOPIC_SHARE) strcat(buffer,(char*)"SHARE ");

return buffer;

}

bool BlockedBotAccess(unsigned int topicid)

}

char* GetRuleTag(int& topicid,int& id,char* tag)

{

// tag is topic.number.number or mearerly topic.number

char* dot = strchr(tag,'.');

topicid = id = 0;

if (!dot) return NULL;

*dot = 0;

topicid = FindTopicIDByName(tag);

*dot = '.';

if (!topicid || !IsDigit(dot[1])) return NULL;

id = atoi(dot+1);

dot = strchr(dot+1,'.');

if (dot && IsDigit(dot[1])) id |= MAKE_REJOINDERID(atoi(dot+1));

return GetRule(topicid,id);

}

char* GetLabelledRule(int& topicid, char* label,char* notdisabled,bool &fulllabel, bool& crosstopic,int& id, int baseTopic)

{

// ~ means current rule

// 0 means current top rule (a would be current a rule above us)

// name means current topic and named rule

// ~xxx.name means specified topic and named rule

id = 0;

fulllabel = false;

crosstopic = false;

topicid = baseTopic;

if (*label == '~' && !label[1]) // ~ means current rule

{

id = currentRuleID;

return currentRule;

}

else if (*label == '0' && label[1] == 0 ) // 0 means current TOP rule

{

id = TOPLEVELID(currentRuleID);

return GetRule(topicid,id);

}

else if (!*label) return NULL;

char* dot = strchr(label,'.');

if (dot) // topicname.label format

{

fulllabel = true;

*dot = 0;

topicid = FindTopicIDByName(label);

if (!topicid) topicid = currentTopicID;

else crosstopic = true;

label = dot+1; // the label

*dot = '.';

}

return FindNextLabel(topicid,label, GetTopicData(topicid),id,!*notdisabled);

}

char* GetVerify(char* tag,int &topicid, int &id) // ~topic.#.#=LABEL<~topic.#.# is a maximally complete why

{

topicid = 0;

id = -1;

if (!*tag) return "";

char* verify = AllocateStack(NULL,MAX_WORD_SIZE); // verify input is small, this is safe

char topicname[MAX_WORD_SIZE];

strcpy(topicname,tag);

char* dot;

dot = strchr(topicname,'.'); // split of primary topic from rest of tag

*dot = 0;

if (IsDigit(*tag)) strcpy(topicname,GetTopicName(atoi(tag)));

char file[SMALL_WORD_SIZE];

WORDP D = FindWord(topicname);

if (!D) return "";

sprintf(file,(char*)"VERIFY/%s-b%c.txt", topicfolder+1, (D->internalBits & BUILD0) ? '0' : '1');

topicid = FindTopicIDByName(topicname,true);

*dot = '.';

char* rest = GetRuleIDFromText(tag,id); // rest is tag or label or end

char c = *rest;

*rest = 0; // tag is now pure

// get verify file of main topic if will have preference over caller

char display[MAX_WORD_SIZE];

FILE* in = FopenReadOnly(file); // VERIFY folder

if (in)

{

while (ReadALine(display,in) >= 0) // find matching verify

{

char word[MAX_WORD_SIZE];

char* ptr = ReadCompiledWord(display,word); // topic + rule info

if (!stricmp(word,tag) && ptr[2] != 'x') // if output rule has a tag use that - ignore comment rules

{

char junk[MAX_WORD_SIZE];

ptr = ReadCompiledWord(ptr,junk); // skip the marker

strcpy(verify,ptr);

break;

}

}

FClose(in);

}

*rest = c;

return verify;

}

char* GetRule(int topicid, int id)

{

if (!topicid || topicid > (int)numberOfTopics || id < 0) return NULL;

topicBlock* block = TI(topicid);

int ruleID = TOPLEVELID(id);

int maxrules = RULE_MAX(block->topicMaxRule);

if (ruleID >= maxrules) return NULL;

char* rule = GetTopicData(topicid);

if (!rule) return NULL;

int rejoinderID = REJOINDERID(id);

rule += block->ruleOffset[ruleID]; // address of top level rule

while (rejoinderID--)

{

rule = FindNextRule(NEXTRULE,rule,ruleID);

if (!Rejoinder(rule)) return NULL; // ran out of rejoinders

}

return rule;

}

void AddTopicFlag(int topicid,unsigned int flag)

}

void RemoveTopicFlag(int topicid,unsigned int flag)

}

}

char* GetTopicName(unsigned int topicid,bool actual)

{

topicBlock* block = TI(topicid);

if (!topicid || !block || !block->topicName) return "";

if (actual) return block->topicName; // full topic name (if duplicate use number)

static char name[MAX_WORD_SIZE];

strcpy(name,block->topicName);

char* dot = strchr(name,'.'); // if this is duplicate topic name, use generic base name

if (dot) *dot = 0;

return name;

}

static char* RuleTypeName(char type)

{

char* name;

if (type == GAMBIT) name = "gambits";

else if (type == QUESTION) name = "questions";

else if (type == STATEMENT) name = "statements";

else if (type == STATEMENT_QUESTION) name = "responders";

else name = "unknown";

return name;

}

void SetTopicData(unsigned int topicid,char* data)

}

static char* GetTopicBlockData(unsigned int topicid)

{

topicBlock* block = TI(topicid);

if (!topicid || !block->topicScript) return NULL;

if (topicid > numberOfTopics) return 0;

char* data = block->topicScript; // predefined topic or user private topic

if (!data || !*data) return NULL;

return data;

}

char* GetTopicData(unsigned int topicid)

{

char* data = GetTopicBlockData(topicid); // predefined topic or user private topic

if (!data || !*data) return NULL;

if (data[0] == '(') // has locals

{

char* at = strchr(data,')');

if (!at) return 0;

data = at + 2;

}

return (data+JUMP_OFFSET); // point past accellerator to the t:

}

void WalkTopics(char* function, char* buffer)

}

char* GetTopicLocals(int topicid)

{

char* data = GetTopicBlockData(topicid); // predefined topic or user private topic

if (data && data[0] == '(') // has locals

{

char* at = strchr(data,')');

return (at) ? data : NULL;

}

return NULL;

}

unsigned int FindTopicIDByName(char* name,bool exact)

}

void UndoErase(char* ptr,int topicid,int id)

}

char* FindNextRule(signed char level, char* ptr, int& id)

{ // level is NEXTRULE or NEXTTOPLEVEL

if (!ptr || !*ptr) return NULL;

char* start = ptr;

unsigned int offset = Decode(ptr-JUMP_OFFSET);

if (offset == 0) return NULL; // end of the line

if (ptr[1] != ':')

{

if (buildID) BADSCRIPT((char*)"TOPIC-10 In topic %s missing colon for responder %s - look at prior responder for bug",GetTopicName(currentTopicID) ,ShowRule(ptr))

ReportBug((char*)"not ptr start of responder %d %s %s - killing data",currentTopicID, GetTopicName(currentTopicID) ,tmpWord)

TI(currentTopicID)->topicScript = 0; // kill off data

return NULL;

}

ptr += offset; // now pointing to next responder

if (Rejoinder(ptr)) id += ONE_REJOINDER;

else id = TOPLEVELID(id) + 1;

if (level == NEXTRULE || !*ptr) return (*ptr) ? ptr : NULL; // find ANY next responder- we skip over + x x space to point ptr t: or whatever - or we are out of them now

while (*ptr) // wants next top level

{

if (ptr[1] != ':')

{

char word[MAX_WORD_SIZE];

strncpy(word,ptr,50);

word[50] = 0;

if (buildID) BADSCRIPT((char*)"TOPIC-11 Bad layout starting %s %c %s",word,level,start)

ReportBug((char*)"Bad layout bug1 %c The rule just before here may be faulty %s",level,start)

return NULL;

}

if (TopLevelRule(ptr)) break; // found next top level

offset = Decode(ptr-JUMP_OFFSET);

if (!offset) return NULL;

ptr += offset; // now pointing to next responder

if (Rejoinder(ptr)) id += ONE_REJOINDER;

else id = TOPLEVELID(id) + 1;

}

return (*ptr) ? ptr : NULL;

}

bool TopLevelQuestion(char* word)

}

bool TopLevelStatement(char* word)

}

bool TopLevelGambit(char* word)

}

bool TopLevelRule(char* word)

}

bool Rejoinder(char* word)

}

int HasGambits(int topicid) // check each gambit to find a usable one (may or may not match by pattern)

}

char* ShowRule(char* rule,bool concise,bool pattern)

{

if (rule == NULL) return "?";

static char result[300];

result[0] = rule[0];

result[1] = rule[1];

result[2] = ' ';

result[3] = 0;

// get printable fragment

char word[MAX_WORD_SIZE];

char label[MAX_WORD_SIZE];

char* ruleAfterLabel = GetLabel(rule,label);

strncpy(word,ruleAfterLabel,(concise) ? 40 : 90);

word[(concise) ? 40 : 90] = 0;

if ((int)strlen(word) >= ((concise) ? 40 : 90)) strcat(word,(char*)"... ");

char* at = strchr(word,ENDUNIT);

if (at) *at = 0; // truncate at end

CleanOutput(word);

strcat(result,label);

strcat(result,(char*)" ");

strcat(result,word);

return result;

}

char* GetPattern(char* ptr, char* label, char* pattern, bool friendly, int limit)

{

if (label) *label = 0;

if (!ptr || !*ptr) return NULL;

if (ptr[1] == ':') ptr = GetLabel(ptr, label);

else ptr += 3; // why ever true?

char* patternStart = ptr;

// acquire the pattern data of this rule

if (*patternStart == '(') ptr = BalanceParen(patternStart + 1, true, false); // go past pattern to new token

int patternlen = ptr - patternStart;

char* to = pattern;

if (pattern)

{

*pattern = 0;

if (patternlen > limit)

{

if (!friendly)

{

ReportBug("GetPattern exceeded limit of %d from %d\r\n", limit, patternlen);

return pattern;

}

patternlen = limit - 1;

}

strncpy(pattern, patternStart, patternlen); // literal copy of internal pattern

pattern[patternlen] = 0;

if (!friendly) return ptr;

// for printouts, get prettier form

char name[MAX_WORD_SIZE];

char word[MAX_WORD_SIZE];

strcpy(word, pattern);

size_t len = strlen(word) - 1;

char* from = word - 1;

bool blank = true;

while (*++from)

{

if (!friendly) {}

else if (*from == '=' && blank) // this is a relational test

{

if (!from[1]) break; // end of data before accelerator

char* compare = from + Decode(from + 1, 1); // use accelerator to point to op in the middle

if (compare > (word + len))

break; // passes limited area

char c = *compare;

if (c == '=' || c == '<' || c == '>' || c == '!' || c == '?' || c == '&')

{

++from;

blank = false;

continue;

}

}

else if (*from == '*' && (IsAlphaUTF8(from[1]) || from[1] == '*')) // find partial word

{

ReadCompiledWord(from, name);

if (strchr(from + 1, '*'))

{

blank = false;

continue;

}

}

else if (*from == '\\' && blank) *to++ = *from++; // literal next

to[1] = 0;

*to++ = *from;

if (blank && *from == '!') { ; } // !_0?~fruit comparison

else blank = (*from == ' ');

}

*to = 0;

}

return ptr; // start of output ptr

}

char* GetOutputCopy(char* ptr)

{

static char buffer[MAX_WORD_SIZE];

if (!ptr || !*ptr) return NULL;

if (ptr[1] == ':') ptr = GetLabel(ptr,NULL);

else ptr += 3; // why ever true?

char* patternStart = ptr;

// acquire the pattern data of this rule

if (*patternStart == '(') ptr = BalanceParen(patternStart+1,true,false); // go past pattern to new token

char* end = strchr(ptr,ENDUNIT);

if (end)

{

size_t len = end-ptr;

strncpy(buffer,ptr,len);

buffer[len] = 0;

}

else strcpy(buffer,ptr);

return buffer; // start of output ptr

}

char* GetLabel(char* rule,char* label)

{

if (label) *label = 0;

if (!rule || !*rule) return NULL;

rule += 3; // skip kind and space

char c = *rule;

if (c == '('){;} // has pattern and no label

else if (c == ' ') ++rule; // has no pattern and no label

else // there is a label

{

unsigned int len = 0; // contains length of label + 2 (1char the byte jump, 1 char the space after the label before (

++rule; // past jump code onto label maybe

if (c < '0') // 2 character label length

{

len = (40 * (c - '*'));

c = *rule++; // past jump code for sure

}

len += c - '0' - 2;

if (label)

{

if (len >= MAX_LABEL_SIZE) len = MAX_LABEL_SIZE-1;

strncpy(label,rule,len); // added 2 in scriptcompiler... keeping files compatible

label[len] = 0;

}

rule += len + 1; // start of pattern ( past space

}

return rule;

}

char* FindNextLabel(int topicid,char* label, char* ptr, int &id,bool alwaysAllowed)

{ // id starts at 0 or a given id to resume hunting from

// Alwaysallowed (0=false, 1= true, 2 = rejoinder) would be true coming from enable or disable, for example, because we want to find the

// label in order to tamper with its availablbilty.

bool available = true;

while (ptr && *ptr)

{

bool topLevel = !Rejoinder(ptr);

if (topLevel) available = (alwaysAllowed) ? true : UsableRule(topicid,id);

// rule is available if a top level available rule OR if it comes under the current rule

if ((available || TOPLEVELID(id) == (unsigned int) currentRuleID) )

{

char ruleLabel[MAX_WORD_SIZE];

GetLabel(ptr,ruleLabel);

if (!stricmp(label,ruleLabel)) return ptr;// is it the desired label?

}

ptr = FindNextRule(NEXTRULE,ptr,id); // go to end of this one and try again at next responder (top level or not)

}

id = -1;

return NULL;

}

int GetTopicFlags(int topicid)

{

return (!topicid || topicid > (int)numberOfTopics) ? 0 : TI(topicid)->topicFlags;

}

void SetTopicDebugMark(int topicid,unsigned int value)

}

void SetTopicTimingMark(int topicid, unsigned int value)

}

void SetDebugRuleMark(int topicid,unsigned int id)

}

static bool HasDebugRuleMark(int topicid)

}

bool AreDebugMarksSet()

}

static bool GetDebugRuleMark(int topicid,unsigned int id) // has this top level responder been marked for debug

}

void SetTimingRuleMark(int topicid, unsigned int id)

}

static bool HasTimingRuleMark(int topicid)

}

bool AreTimingMarksSet()

}

static bool GetTimingRuleMark(int topicid, unsigned int id) // has this top level responder been marked for timing

}

void FlushDisabled()