#include "common.h"

#include "common.h"

#include "common.h"

#define MAX_NO_ERASE 300

#define MAX_REPEATABLE 300

#define TOPIC_LIMIT 10000

bool allNoStay = false;

bool hypotheticalMatch = false;

int currentBeforeLayer = 0;

int hasFundamentalMeanings = 0;

bool noteRulesMatching = false;

HEAPREF rulematches = NULL;

WORDP keywordBase = NULL;

WORDP* changedWordsDuringLoading = NULL; // list of words changing data during topic loading

bool monitorChange = false;

WORDP undefinedFunction[100];

unsigned int undefinedFunctionIndex = 0;

char* textBase = NULL;

static void ClearFastLoad(const char* topicfolder, const char* name);

// functions that manage topic execution (hence displays) are: PerformTopic (gambit, responder),

// Reusecode, RefineCode, Rejoinder, Plan

// max toplevel rules in a RANDOM topic

unsigned int numberOfTopics = 0;

unsigned int numberOfTopicsInLayer[NUMBER_OF_LAYERS + 1];

topicBlock* topicBlockPtrs[NUMBER_OF_LAYERS + 1];

bool norejoinder = false;

HEAPREF unwindUserLayer = NULL;

// current operating data

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

// rejoinder info

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 = "";

// block erasing with this

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

static unsigned int keepIndex;

// allow repeats with this

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

static unsigned int repeatableIndex;

// current flow of topic control stack

int topicIndex = 0;

int topicStack[MAX_TOPIC_STACK + 1];

// pending topics

int pendingTopicIndex = 0;

int pendingTopicList[MAX_TOPIC_STACK + 1];

int originalPendingTopicList[MAX_TOPIC_STACK + 1];

int originalPendingTopicIndex = 0;

// debug information

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* ptr = word - 1;

while (*++ptr)

{

if (ptr == word && *ptr == '=' && ptr[1] != ' ') memmove(ptr, ptr + 2, strlen(ptr + 1)); // comparison operator - remove header

else if (ptr == word && *ptr == '*' && IsAlphaUTF8(ptr[1])) memmove(ptr, ptr + 1, strlen(ptr)); // * partial word match- remove header

else if ((*ptr == ' ' || *ptr == '!') && ptr[1] == '=' && ptr[2] != ' ') memmove(ptr + 1, ptr + 3, strlen(ptr + 2)); // comparison operator - remove header

else if (*ptr == ' ' && ptr[1] == '*' && IsAlphaUTF8(ptr[2])) memmove(ptr + 1, ptr + 2, strlen(ptr + 1)); // * partial word match- remove header

}

}

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;

}

///////////////////////////////////////////

/// ENCODE/DECODE

///////////////////////////////////////////

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

{

*data++ = 'a';

*data++ = 'a';

*data++ = 'a';

}

bool DifferentTopicContext(int depthadjust, int topicid)

{

int depth = globalDepth + depthadjust + 1;

while (--depth > 0) // start from prior to us

{

CALLFRAME* frame = frameList[depth];

if (*frame->label == '~') return topicid != (int)frame->oldTopic;

if (*frame->label == '^' && frame->code) return true; // user function breaks chain of access

}

return true;

}

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

{ // digits are base 75

if (size == 1)

{

*ptr = code[val % USED_CODES];

return;

}

else if (size == 2)

{

*ptr++ = code[val / USED_CODES];

*ptr++ = code[val % USED_CODES];

return;

}

if (val > (USED_CODES * USED_CODES * USED_CODES)) ReportBug((char*)"Encode val too big");

int digit1 = val / (USED_CODES * USED_CODES);

ptr[0] = code[digit1];

val -= (digit1 * USED_CODES * USED_CODES);

ptr[1] = code[val / USED_CODES];

ptr[2] = code[val % USED_CODES];

}

unsigned int Decode(char* data, int size)

{

if (size == 1) return uncode[*data];

else if (size == 2)

{

unsigned int val = uncode[*data++] * USED_CODES;

val += uncode[*data++];

return val;

}

unsigned int val = uncode[*data++] * (USED_CODES * USED_CODES);

val += uncode[*data++] * USED_CODES;

val += uncode[*data++];

return val;

}

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

{

char* ptr = data + strlen(data);

uint64 val = uncode[*--ptr];

while (ptr != data) val = (val * USED_CODES) + uncode[*--ptr];

return val;

}

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

{

FILE* in;

WORDP D = FindWord(GetTopicName(topicid, true));

if (D)

{

char file[SMALL_WORD_SIZE];

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

in = FopenReadOnly(file); // VERIFY folder

if (in) // we found the file, now find any verfiy if we can

{

char tag[MAX_WORD_SIZE];

sprintf(tag, (char*)"%s.%u.%u", GetTopicName(topicid), TOPLEVELID(ruleID), REJOINDERID(ruleID));

char verify[MAX_WORD_SIZE];

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

{

char word[MAX_WORD_SIZE];

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

if (!stricmp(word, tag)) // if output rule has a tag use that

{

char junk[MAX_WORD_SIZE];

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

Log(how, (char*)" sample: #! %s", ptr);

break;

}

}

FClose(in);

}

}

}

///////////////////////////////////////////////////////

///// TOPIC DATA ACCESSORS

///////////////////////////////////////////////////////

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)

{

unsigned char count = 0;

while (n)

{

count++;

n &= n - 1;

}

return count;

}

int TopicUsedCount(int topicid)

{

topicBlock* block = TI(topicid);

int size = block->topicBytesRules;

unsigned char* bits = block->topicUsed;

int test = 0;

unsigned int count = 0;

while (++test < size) count += ByteCount(*bits++);

return count;

}

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)

{

if (!topicid || topicid > numberOfTopics) return true;

topicBlock* block = TI(topicid);

if (block->topicFlags & TOPIC_BLOCKED) return true;

return (block->topicRestriction && !strstr(block->topicRestriction, computerIDwSpace));

}

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", topicname + 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)

{

if (topicid > (int)numberOfTopics || !topicid)

ReportBug((char*)"AddTopicFlag flags topic id %d out of range\r\n", topicid);

else TI(topicid)->topicFlags |= flag;

}

void RemoveTopicFlag(int topicid, unsigned int flag)

{

if (topicid > (int)numberOfTopics || !topicid) ReportBug((char*)"RemoveTopicFlag flags topic %d out of range\r\n", topicid);

else

{

TI(topicid)->topicFlags &= -1 ^ flag;

AddTopicFlag(topicid, TOPIC_USED);

}

}

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)

{

if (topicid > numberOfTopics) ReportBug((char*)"SetTopicData id %u out of range\r\n", topicid);

else TI(topicid)->topicScript = 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)

{

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

{

if (!*GetTopicName(i)) continue;

topicBlock* block = TI(i);

// skip if current bot cannot access

if (block->topicRestriction && !strstr(block->topicRestriction, computerIDwSpace)) continue;

FunctionResult result;

char word[MAX_WORD_SIZE];

sprintf(word, (char*)"( %s )", GetTopicName(i));

*buffer = 0;

DoFunction(function, word, buffer, result);

}

}

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)

{

if (!name || !*name) return 0;

char word[MAX_WORD_SIZE];

*word = '~';

if (*name == '~' && !name[1])

{

MakeLowerCopy(word, GetTopicName(currentTopicID, false)); // ~ means current topic always

}

else MakeLowerCopy((*name == '~') ? word : (word + 1), name);

WORDP D = FindWord(word, 0, LOWERCASE_LOOKUP);

duplicateCount = 0;

while (D)

{

if (!(D->internalBits & TOPIC)) // concept which may overlap topic usage?

{

++duplicateCount;

sprintf(tmpWord, (char*)"%s%c%u", word, DUPLICATETOPICSEPARATOR, duplicateCount);

D = FindWord(tmpWord);

continue;

}

int topicid = D->x.topicIndex;

if (!topicid)

{

if (!compiling) ReportBug((char*)"Missing topic index for %s\r\n", D->word);

break;

}

topicBlock* block = TI(topicid);

if (exact || !block->topicRestriction || strstr(block->topicRestriction, computerIDwSpace)) return topicid; // legal to this bot

// replicant topics for different bots

++duplicateCount;

sprintf(tmpWord, (char*)"%s%c%u", word, DUPLICATETOPICSEPARATOR, duplicateCount);

D = FindWord(tmpWord);

}

return 0;

}

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

{

if (trace & TRACE_TOPIC && CheckTopicTrace()) Log(USERLOG, "Undoing erase %s\r\n", ShowRule(ptr));

ClearRuleDisableMark(topicid, 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)

{

if (!word || !*word) return false;

if (word[1] != ':') return false;

if (*word != QUESTION && *word != STATEMENT_QUESTION) return false;

// if (word[2] && word[2] != ' ') return false;

return true;

}

bool TopLevelStatement(char* word)

{

if (!word || !*word) return false;

if (word[1] != ':') return false;

if (*word != STATEMENT && *word != STATEMENT_QUESTION) return false;

// if (word[2] && word[2] != ' ') return false;

return true;

}

bool TopLevelVoid(char* word)

{

if (!word || !*word) return false;

if (word[1] != ':') return false;

if (*word == 'v') return true;

return false;

}

bool TopLevelGambit(char* word)

{

if (!word || !*word) return false;

if (word[1] != ':') return false;

if (*word != RANDOM_GAMBIT && *word != GAMBIT) return false;

// if (word[2] && word[2] != ' ') return false;

return true;

}

bool TopLevelRule(char* word)

{

if (!word || !*word) return true; // END is treated as top level

if (TopLevelGambit(word)) return true;

if (TopLevelVoid(word)) return true;

if (TopLevelStatement(word)) return true;

return TopLevelQuestion(word);

}

bool Rejoinder(char* word)

{

if (!word || !*word) return false;

if (word[1] != ':' || !IsAlphaUTF8(*word)) return false;

return (*word >= 'a' && *word <= 'q') ? true : false;

}

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

{

if (BlockedBotAccess(topicid) || GetTopicFlags(topicid) & TOPIC_SYSTEM) return -1;

unsigned int* map = TI(topicid)->gambitTag;

if (!map) return false; // not even a gambit map

unsigned int gambitID = *map;

while (gambitID != NOMORERULES)

{

if (UsableRule(topicid, gambitID)) return 1;

gambitID = *++map;

}

return 0;

}

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[3 * 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)

{

if (!topicid || topicid > (int)numberOfTopics) return;

topicBlock* block = TI(topicid);

block->topicDebug = value;

}

void SetTopicTimingMark(int topicid, unsigned int value)

{

if (!topicid || topicid > (int)numberOfTopics) return;

topicBlock* block = TI(topicid);

block->topicTiming = value;

}

void SetDebugRuleMark(int topicid, unsigned int id)

{

if (!topicid || topicid > (int)numberOfTopics) return;

topicBlock* block = TI(topicid);

id = TOPLEVELID(id);

unsigned int byteOffset = id / 8;

if (byteOffset >= block->topicBytesRules) return; // bad index

unsigned int bitOffset = id % 8;

unsigned char* testByte = block->topicDebugRule + byteOffset;

*testByte ^= (unsigned char)(0x80 >> bitOffset);

}

static bool HasDebugRuleMark(int topicid)

{

if (!topicid || topicid > (int)numberOfTopics) return false;

bool tracing = false;

topicBlock* block = TI(topicid);

for (int i = 0; i < block->topicBytesRules; ++i)

{

if (block->topicDebugRule[i])

{

tracing = true;

Log(USERLOG, " Some rule(s) being traced in %s\r\n", GetTopicName(topicid));

}

}

return tracing;

}

bool AreDebugMarksSet()

{

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

{

if (HasDebugRuleMark(i)) return true;

}

return false;

}

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

{

if (!topicid || topicid > (int)numberOfTopics) return false;

topicBlock* block = TI(topicid);

id = TOPLEVELID(id);

unsigned int byteOffset = id / 8;

if (byteOffset >= block->topicBytesRules) return false; // bad index

unsigned int bitOffset = id % 8;

unsigned char* testByte = block->topicDebugRule + byteOffset;

unsigned char value = (*testByte & (unsigned char)(0x80 >> bitOffset));

return value != 0;

}

void SetTimingRuleMark(int topicid, unsigned int id)

{

if (!topicid || topicid > (int)numberOfTopics) return;

topicBlock* block = TI(topicid);

id = TOPLEVELID(id);

unsigned int byteOffset = id / 8;

if (byteOffset >= block->topicBytesRules) return; // bad index

unsigned int bitOffset = id % 8;

unsigned char* testByte = block->topicTimingRule + byteOffset;

*testByte ^= (unsigned char)(0x80 >> bitOffset);

}

static bool HasTimingRuleMark(int topicid)

{

if (!topicid || topicid > (int)numberOfTopics) return false;

bool doTiming = false;

topicBlock* block = TI(topicid);

for (int i = 0; i < block->topicBytesRules; ++i)

{

if (block->topicTimingRule[i])

{

doTiming = true;

Log(USERLOG, " Some rule(s) being timed in %s\r\n", GetTopicName(topicid));

}

}

return doTiming;

}

bool AreTimingMarksSet()

{

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

{

if (HasTimingRuleMark(i)) return true;

}

return false;

}

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