#include "common.h"

#pragma warning(disable: 4068)

extern int ignoreRule;

static bool down_is = true;

char priorLogin[ID_SIZE];

unsigned int priortrace = 0;

static int downcount = 0;

static char verifybot[100];

static char verifylanguage[100];

static char verifylanguagelc[100];

static char verifybotlc[100];

static int volleyCounter = 0;

static int relevantVolleyCounter = 0;

static int itemcount = 0;

bool nomixedcase = false;

bool noconcept = false;

static void GetAffect(WORDP D, unsigned int restriction, int& good, int& bad);

void InitStats()

{

preparationtime = 0;

replytime = 0;

timerCheckInstance = 0;

modifiedTraceVal = 0;

modifiedTrace = false;

modifiedTimingVal = 0;

modifiedTiming = false;

rulesExecuted = 0;

patternEvaluationCount = 0;

timeSummary.clear();

rulesExecuted = 0;

timerCheckInstance = 0;

modifiedTraceVal = 0;

modifiedTrace = false;

modifiedTimingVal = 0;

modifiedTiming = false;

}

bool VerifyAuthorization(FILE* in) // is he allowed to use :commands

{

if (scriptOverrideAuthorization || !strnicmp(GetUserVariable("$bwtrace"), serverlogauthcode, strlen(serverlogauthcode)))

{

if (in) FClose(in);

return true; // commanded from script

}

char buffer[MAX_WORD_SIZE];

if (*authorizations == '1') // command line does not authorize

{

if (in) FClose(in);

return false;

}

// check command line params

char* at = authorizations;

char word[MAX_WORD_SIZE];

if (at) // command line given

{

if (*at == '"') ++at;

while (*at)

{

at = ReadCompiledWord(at, word);

size_t len = strlen(word);

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

if (!stricmp(word, (char*)"all") || !stricmp(word, callerIP) || (*word == 'L' && word[1] == '_' && !stricmp(word + 2, loginID))) // allowed by IP or L_loginname

{

if (in) FClose(in);

return true;

}

}

}

if (!in) return (*authorizations) ? false : true; // no restriction file

bool result = false;

while (ReadALine(buffer, in) >= 0)

{

ReadCompiledWord(buffer, word);

if (!stricmp(word, (char*)"all") || !stricmp(word, callerIP) || (*word == 'L' && word[1] == '_' && !stricmp(word + 2, loginID)) || (*word == 'P' && word[1] == '_' && strstr(loginID, word + 2))) // allowed by IP or L_loginname or P_loginname

{

result = true;

break;

}

}

FClose(in);

return result;

}

#ifndef DISCARDTESTING

static void C_Trace(char* input);

static void C_DoInternal(char* input, bool internal);

static int nooob = 0;

static int lineLimit = 0; // in abstract report lines that are longer than this...

static WORDP topLevel = 0;

static unsigned int err = 0;

static int inLine = 0;

static int inDepth = 0;

static unsigned int filesSeen;

static char directory[MAX_WORD_SIZE];

static char* abstractBuffer;

static int longLines;

static uint64 verifyToken;

static bool isTracing = false;

static bool isTiming = false;

static WORDP dictUsedG;

static FACT* factUsedG;

static char* textUsedG;

static int trials;

static int nextRule = 0;

static bool keepname = false;

static void TrimIt(char* name, uint64 flag);

#define ABSTRACT_SPELL 1

#define ABSTRACT_SET_MEMBER 2

#define ABSTRACT_CANONICAL 4

#define ABSTRACT_PRETTY 8

#define ABSTRACT_VP 16

#define ABSTRACT_NOCODE 32

#define ABSTRACT_STORY 64

#define ABSTRACT_RESPONDER 128

#define ABSTRACT_RESTRICTIONS (ABSTRACT_SPELL|ABSTRACT_SET_MEMBER|ABSTRACT_CANONICAL|ABSTRACT_VP )

#define ABSTRACT_COVERAGE 256

static bool fromScript = false;

static void ShowTrace(unsigned int bits, bool original);

static void ShowTiming(unsigned int bits, bool original);

// prototypes

static bool DumpOne(WORDP S, int all, int depth, bool shown);

static int CountDown(MEANING T, int all, int depth, unsigned int baseStamp);

static void C_Retry(char* input);

static MEANING* meaningList; // list of meanings from :concepts

static MEANING* meaningLimit; // end of meaninglistp

#include <map>

using namespace std;

std::map <const char*, int> statistics; // statistics data

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

/// UTILITY ROUTINES

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

int CountSet(WORDP D, unsigned int baseStamp) // full recursive referencing

{

if (!D) return 0;

if (D->inferMark == inferMark) return 0;

D->inferMark = inferMark;

int count = 0;

FACT* F = GetObjectNondeadHead(D);

FACT* G;

while (F) // do all atomic members of it

{

G = F;

F = GetObjectNondeadNext(F);

WORDP S = Meaning2Word(G->subject);

if (!(G->verb == Mmember) || G->flags & FACTDEAD) continue;

if (*S->word == '~') continue;

else if (Meaning2Index(G->subject)) count += CountDown(GetMaster(G->subject), -1, -2, baseStamp); // word~2 reference is a synset header -- follow IS_A submembers

else // simple atomic member -- or POS specificiation

{

if (S->inferMark <= baseStamp) // count once

{

S->inferMark = inferMark;

++count;

}

}

}

F = GetObjectNondeadHead(D);

while (F) // do all set members of it

{

G = F;

F = GetObjectNondeadNext(F);

WORDP S = Meaning2Word(G->subject);

if (!(G->verb == Mmember) || G->flags & FACTDEAD) continue;

if (*S->word == '~') count += CountSet(S, baseStamp);

}

return count;

}

static int CountDown(MEANING T, int all, int depth, unsigned int baseStamp)

{ // T is a synset header

T &= -1 ^ SYNSET_MARKER;

if (all == 5) return 0;

int count = 0;

// show each word in synset

WORDP D = Meaning2Word(T);

WORDP baseWord = D;

unsigned int index = Meaning2Index(T);

unsigned int baseIndex = index;

// walk the master list of synonyms at this level

bool shown = false;

while (index)

{

MEANING next = GetMeaning(D, index);

if (D->inferMark != inferMark)

{

if (D->inferMark <= baseStamp) ++count;

D->inferMark = inferMark;

if (depth >= 0) shown |= DumpOne(D, all, depth, shown); // display it

}

D = Meaning2Word(next);

index = Meaning2Index(next);

if (D == baseWord && index == baseIndex) break; // back at start of loop

}

// down go down to next level synset from this one

FACT* F = GetObjectNondeadHead(T);

while (F)

{

if (F->verb == Mis && F->object == T) count += CountDown(F->subject, all, (depth == -2) ? -2 : (depth + 1), baseStamp);

F = GetObjectNondeadNext(F);

}

return count;

}

static void Indent(int count, bool nonumber)

{

if (!nonumber) Log(USERLOG, "%d.", count);

while (count--) Log(USERLOG, " ");

}

static bool DumpOne(WORDP S, int all, int depth, bool shown)

{

bool did = false;

if (all)

{

if (all == 3) return false;

if (itemcount == 0 && all != 2) Indent(depth, shown);

unsigned char* data = GetWhereInSentence(S);

if (all == 1)

{

if (!data)

{

data = (unsigned char*)AllocateWhereInSentence(S);

if (!data) return false;

*data = 0;

data[1] = 0;

}

if (++data[1] == 0) ++data[0];

}

if (all == 1 && *data && (data[0] || data[1] > 1)) Log(USERLOG, "+%s ", S->word); // multiple occurences

else // first occurence of word

{

if (all == 1 && !(S->systemFlags & VERB_DIRECTOBJECT)) // generate a list of intransitive verbs

{

FILE* out = FopenUTF8WriteAppend((char*)"intransitive.txt");

fprintf(out, (char*)"%s 1\r\n", S->word);

FClose(out);

}

if (all == 1 && (S->systemFlags & VERB_INDIRECTOBJECT)) // generate a list of dual transitive verbs

{

FILE* out = FopenUTF8WriteAppend((char*)"intransitive.txt");

fprintf(out, (char*)"%s 2\r\n", S->word);

FClose(out);

}

Log(USERLOG, "%s ", S->word);

}

++itemcount;

if (itemcount == 10 && all != 2)

{

Log(USERLOG, "\r\n");

itemcount = 0;

}

did = true;

}

return did;

}

static void MarkExclude(WORDP D)

{

FACT* F = GetObjectNondeadHead(D);

while (F)

{

if (F->verb == Mexclude) Meaning2Word(F->subject)->inferMark = inferMark;

else if (F->verb == Mmember) break;

F = GetObjectNondeadNext(F);

}

}

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

/// TESTING

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

static void C_AutoReply(char* input)

{

regression = 1;

strcpy(oktest, input);

if (!*oktest) regression = 0;

if (*oktest) Log(USERLOG, "Auto input set to %s\r\n", oktest);

}

static void MarkUp(WORDP D) // mark all that can be seen from here going up as member

{

if (D->inferMark == inferMark) return;

D->inferMark = inferMark;

FACT* F = GetSubjectNondeadHead(D);

while (F)

{

if (F->verb == Mmember)

{

WORDP E = Meaning2Word(F->object);

MarkUp(E);

}

F = GetSubjectNondeadNext(F);

}

}

static void C_Common(char* input)

{

char word[MAX_WORD_SIZE];

char word1[MAX_WORD_SIZE];

WORDP D = NULL;

char* ptr = ReadCompiledWord(input, word);

ptr = ReadCompiledWord(ptr, word1);

if (!*word1)

{

Log(USERLOG, "You need to supply at least 2 words.\r\n");

return;

}

while (input)

{

input = ReadCompiledWord(input, word);

D = FindWord(word);

if (!D)

{

Log(USERLOG, "%s is an unknown word\r\n", word);

return;

}

ReadCompiledWord(input, word1); // read ahead 1

if (!*word1) break; //we are on the last word

FACT* F = GetSubjectNondeadHead(D);

NextInferMark();

while (F)

{

TraceFact(F);

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

MarkUp(Meaning2Word(F->object)); // mark all on this path as seen

F = GetSubjectNondeadNext(F);

}

}

WORDP words[10000];

WORDP found[10000];

NextInferMark();

unsigned int index = 0;

unsigned int at = 0;

unsigned int foundIndex = 0;

words[index++] = D; // goes onto stack

words[index++] = 0; // end of a level

int level = 0;

FACT* F;

while (at < index)

{

D = words[at++]; // next one from queue

if (D == 0)

{

if (at != index) words[index++] = 0;

++level;

found[foundIndex++] = 0; // mark the level

continue;

}

F = GetSubjectNondeadHead(D);

while (F)

{

if (F->verb == Mmember)

{

D = Meaning2Word(F->object);

if (D->inferMark == (inferMark - 1)) found[foundIndex++] = D;

if (D->inferMark < inferMark)

{

D->inferMark = inferMark;

words[index++] = D;

}

}

F = GetSubjectNondeadNext(F);

}

}

Log(USERLOG, "Concept intersection:\r\n");

level = 1;

bool header = false;

for (unsigned int i = 0; i < foundIndex; ++i)

{

if (found[i] == 0)

{

Log(USERLOG, "\r\n");

++level;

header = false;

}

else

{

if (!header) Log(USERLOG, "%d. ", level);

header = true;

Log(USERLOG, "%s ", found[i]->word);

}

}

Log(USERLOG, "\r\n");

}

static void C_NoReact(char* input)

{

noReact = !noReact;

Log(USERLOG, "Noreact = %d\r\n", noReact);

}

static void C_Plural(char* input)

{

char plu[MAX_WORD_SIZE];

char* plural = GetPluralNoun(input, plu);

if (plural) printf("%s\r\n", plural);

else printf("unknown\r\n");

}

static void C_POS(char* input)

{

if (!*input) prepareMode = (prepareMode == POS_MODE) ? NO_MODE : POS_MODE;

else

{

unsigned int oldtrace = trace;

unsigned int oldtiming = timing;

uint64 oldTokenControl = tokenControl;

char word[MAX_WORD_SIZE];

char* at = ReadCompiledWord(input, word);

if (!stricmp(word, (char*)"PENN"))

{

input = at;

tokenControl = STRICT_CASING | DO_ESSENTIALS | DO_PARSE | DO_CONTRACTIONS | NO_HYPHEN_END | NO_COLON_END | NO_SEMICOLON_END | TOKEN_AS_IS;

}

else

{

char* token = GetUserVariable("$cs_token", false);

int64 f;

ReadInt64(token, f);

if (f == 0) f = DO_ESSENTIALS | DO_PARSE | DO_CONTRACTIONS | NO_HYPHEN_END | NO_COLON_END | NO_SEMICOLON_END | TOKEN_AS_IS;

tokenControl = f;

}

trace = (unsigned int)-1;

tmpPrepareMode = POS_MODE;

quotationInProgress = 0;

PrepareSentence(input, true, true);

tmpPrepareMode = NO_MODE;

tokenControl = oldTokenControl;

trace = (modifiedTrace) ? modifiedTraceVal : oldtrace;

timing = (modifiedTiming) ? modifiedTimingVal : oldtiming;

}

}

static void C_Prepare(char* input)

{

uint64 oldToken = tokenControl;

input = SkipWhitespace(input);

static bool prepass = true;

char word[MAX_WORD_SIZE];

if (*input == USERVAR_PREFIX) // set token control to this

{

char* ptr = ReadCompiledWord(input, word);

char* value = GetUserVariable(word, false);

if (value && *value)

{

input = ptr;

int64 val64 = 0;

ReadInt64(value, val64);

tokenControl = val64;

}

}

input = SkipWhitespace(input);

if (!strnicmp(input, (char*)"NOPREPASS", 9) || !strnicmp(input, (char*)"PREPASS", 7))

{

prepass = strnicmp(input, (char*)"NOPREPASS", 9) ? true : false;

input = ReadCompiledWord(input, word);

}

if (!*input) prepareMode = (prepareMode == PREPARE_MODE) ? NO_MODE : PREPARE_MODE;

else

{

char prepassTopic[MAX_WORD_SIZE];

strcpy(prepassTopic, GetUserVariable("$cs_prepass", false));

unsigned int oldtrace = trace;

unsigned int oldtiming = timing;

AddInput(input, 0, true);

input = GetNextInput();

bool oobstart = (input && *input == '[');

bool oldecho = echo;

echo = true;

char* ptr = ourMainOutputBuffer;

while ((input = GetNextInput()))

{

prepareMode = PREPARE_MODE;

if (*prepassTopic) Log(USERLOG, "Prepass: %s\r\n", prepass ? (char*)"ON" : (char*)"OFF");

PrepareSentence(input, true, true, false, oobstart); // std prepare

oobstart = false;

prepareMode = NO_MODE;

trace |= TRACE_PREPARE;

if (prepass && PrepassSentence(prepassTopic)) continue;

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

{

strcpy(ptr, wordStarts[i]);

ptr += strlen(ptr);

*ptr++ = ' ';

}

*ptr = 0;

if (GetNextInput()) strcpy(ptr++, "|");

}

echo = oldecho;

trace = (modifiedTrace) ? modifiedTraceVal : oldtrace;

timing = (modifiedTiming) ? modifiedTimingVal : oldtiming;

}

tokenControl = oldToken;

}

static void C_Canonize(char* input)

{

uint64 oldToken = tokenControl;

input = SkipWhitespace(input);

static bool prepass = true;

char word[MAX_WORD_SIZE];

if (*input == USERVAR_PREFIX) // set token control to this

{

char* ptr = ReadCompiledWord(input, word);

char* value = GetUserVariable(word, false);

if (value && *value)

{

input = ptr;

int64 val64 = 0;

ReadInt64(value, val64);

tokenControl = val64;

}

}

input = SkipWhitespace(input);

if (!strnicmp(input, (char*)"NOPREPASS", 9) || !strnicmp(input, (char*)"PREPASS", 7))

{

prepass = strnicmp(input, (char*)"NOPREPASS", 9) ? true : false;

input = ReadCompiledWord(input, word);

}

char* ptr = ourMainOutputBuffer;

AddInput(input, 0, true);

char prepassTopic[MAX_WORD_SIZE];

strcpy(prepassTopic, GetUserVariable("$cs_prepass", false));

bool oobstart = (*input == '[');

while ((input = GetNextInput()))

{

PrepareSentence(input, true, true, false, oobstart); // std prepare

oobstart = false;

if (prepass && PrepassSentence(prepassTopic)) continue;

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

{

strcpy(ptr, wordCanonical[i]);

ptr += strlen(ptr);

*ptr++ = ' ';

}

*ptr = 0;

if (GetNextInput()) strcpy(ptr++, "|");

}

Log(USERLOG, "Canonical: %s\r\n", ourMainOutputBuffer);

tokenControl = oldToken;

}

static void C_Spellit(char* input)

{

echo = true;

spellTrace = true;

input = SkipWhitespace(input);

AddInput(input, 0, true);

prepareMode = TOKENIZE_MODE;

while ((input = GetNextInput())) PrepareSentence(input, true, true, false, false);

prepareMode = NO_MODE;

echo = false;

spellTrace = false;

}

static void C_Tokenize(char* input)

{

uint64 oldToken = tokenControl;

input = SkipWhitespace(input);

char word[MAX_WORD_SIZE];

if (*input == USERVAR_PREFIX) // set token control to this

{

char* ptr = ReadCompiledWord(input, word);

char* value = GetUserVariable(word, false);

if (value && *value)

{

input = ptr;

int64 val64 = 0;

ReadInt64(value, val64);

tokenControl = val64;

}

}

AddInput(input, 0, true);

char* ptr = ourMainOutputBuffer;

if (!*input) prepareMode = (prepareMode == TOKENIZE_MODE) ? NO_MODE : TOKENIZE_MODE;

else

{

unsigned int oldtrace = trace;

unsigned int oldtiming = timing;

bool oobstart = (*GetNextInput() == '[');

while ((input = GetNextInput()))

{

prepareMode = TOKENIZE_MODE;

PrepareSentence(input, true, true, false, oobstart);

oobstart = false;

prepareMode = NO_MODE;

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

{

strcpy(ptr, wordStarts[i]);

ptr += strlen(ptr);

*ptr++ = ' ';

}

*ptr = 0;

if (GetNextInput()) strcpy(ptr++, "|");

}

trace = (modifiedTrace) ? modifiedTraceVal : oldtrace;

timing = (modifiedTiming) ? modifiedTimingVal : oldtiming;

}

Log(USERLOG, "Canonical: %s\r\n", ourMainOutputBuffer);

tokenControl = oldToken;

}

static void MemorizeRegress(char* input)

{

char word[MAX_WORD_SIZE];

input = ReadCompiledWord(input, word); // file to read

char outputfile[MAX_WORD_SIZE];

ReadCompiledWord(input, outputfile); // file to write

FILE* in = FopenReadNormal(word); // source full name given

char file[SMALL_WORD_SIZE];

if (!in)

{

char* txt = strstr(word, (char*)".txt");

if (txt) *txt = 0;

sprintf(file, (char*)"%s/log-%s.txt", usersfolder, word); // presume only login given, go find full file

in = FopenReadNormal(file); // source

}

if (!in) Log(USERLOG, "Couldn't find %s\r\n", file);

else

{

FILE* out = NULL;

if (*outputfile) out = FopenUTF8Write(outputfile);

if (!out)

{

char fname[200];

sprintf(fname, "%s/regress.txt", tmpfolder);

strcpy(outputfile, fname);

out = FopenUTF8Write(outputfile);

if (!out)

{

(*printer)((char*)"cannot open %s\r\n", outputfile);

return;

}

}

char* at;

char kind[20];

bool start = true;

while (ReadALine(readBuffer, in) >= 0) // read log file

{

if (!*readBuffer) continue;

size_t len;

// Start: user:fa bot:patient1a ip: rand:247 (~introductions) 0 ==> Hello Doctor When:Mar23'14-20:06:23 Version:4.2 Build0: Build1:Mar23'14-20:04:11 0:Mar23'14-20:06:18 F:0 P:0 Why:~introductions.0.0.~control.6.0

// Respond: user:fa bot:patient1a ip: (~introductions) 1 fa ==> I'm afraid I don't understand that question. When:Mar23'14-20:06:30 Why:~control.10.0=MAINCONTROL

// fields are: type, user, bot, ip, {rand}, (resulting topic), current volley id, user input, ==> bot output, when: {version/build1/build0/f:/p:) followed by why: rule tags for each issued output.

if (!strstr(readBuffer, (char*)"Respond:")) continue; // abnormal line? like a ^log entry.

// normal volley

char user[MAX_WORD_SIZE];

char* ptr = strstr(readBuffer, (char*)"user:") + 5;

ptr = ReadCompiledWord(ptr, user);

unsigned int volley;

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

volley = atoi(endtopic + 2);

int rand = -1;

char* randptr = strstr(ptr, (char*)"rand:");

if (randptr) rand = atoi(randptr + 5);

// confirm legit startup

if (start == true && false)

{

if (volley)

{

Log(USERLOG, "Log file must begin with Start at turn 0, not turn %d\r\n", volley);

FClose(in);

return;

}

start = false;

}

char bot[MAX_WORD_SIZE];

ptr = strstr(readBuffer, (char*)"bot:") + 4;

ptr = ReadCompiledWord(ptr, bot);

char topic[MAX_WORD_SIZE];

at = strchr(ptr, '(') + 1;

*endtopic = 0;

at = ReadCompiledWord(at, topic);

char junk[MAX_WORD_SIZE];

at = endtopic + 2;

at = ReadCompiledWord(at, junk) - 1; // point at blank

char* input = at; // now points to user input start

char* output = strstr(at, (char*)" ==> ");

if (!output) continue;

*output = 0; // end of input

input = SkipWhitespace(input);

output += 5;

output = SkipWhitespace(output); // start of output

char* why = strstr(output, (char*)"Why:");

char* end = strstr(output, (char*)" When:");

if (end) *end = 0; // end of output

if (rand != -1) fprintf(out, (char*)"%s user:%s bot:%s rand:%u (%s) %u ==> %s\r\n", kind, user, bot, (unsigned int)rand, topic, volley, output);

else fprintf(out, (char*)"%s user:%s bot:%s (%s) %u %s ==> %s\r\n", "Respond:", user, bot, topic, volley, input, output);

if (!why) continue;

why += 4;

end = strchr(why + 1, '~'); // 2nd rule via if there is one

if (end) *end = 0;

int topicid;

int id;

char* verify = GetVerify(why, topicid, id);

if (!verify) continue;

char* rule = GetRule(topicid, id); // the rule we want to test

if (!rule) continue;

char label[MAX_WORD_SIZE];

char pattern[MAX_WORD_SIZE];

char outputdata[MAX_WORD_SIZE];

char* output1 = GetPattern(rule, label, pattern);

len = strlen(output1);

if (len > 50) len = 50;

strncpy(outputdata, output1, len);

while (outputdata[len - 1] == ' ') --len;

outputdata[len] = 0;

pattern[50] = 0; // limit it

fprintf(out, (char*)" verify: %s rule:%s kind:%c label:%s pattern: %s output: %s \r\n", verify, why, *rule, label, pattern, outputdata);

if (!end)

{

fprintf(out, (char*)"%s", (char*)" verify2: \r\n");

continue;

}

*end = '~';

rule = GetRule(topicid, id); // the rule we want to test

output1 = GetPattern(rule, label, pattern);

len = strlen(output1);

if (len > 50) len = 50;

strncpy(outputdata, output1, len);

outputdata[len] = 0;

pattern[50] = 0; // limit it

verify = GetVerify(end, topicid, id);

fprintf(out, (char*)" verify2: %s rule:%s kind:%c label:%s pattern: %s output: %s \r\n", verify, end, *rule, label, pattern, outputdata);

}

FClose(out);

FClose(in);

Log(USERLOG, "Regression file %s created\r\n", outputfile);

}

}

static void VerifyRegress(char* file)

{

char word[MAX_WORD_SIZE];

char* at = ReadCompiledWord(file, word);

bool silent = false;

bool exitrequest = false;

if (!stricmp(word, (char*)"exit") || !stricmp(word, (char*)"batch"))

{

file = at;

exitrequest = true;

at = ReadCompiledWord(file, word);

}

if (!stricmp(word, (char*)"terse"))

{

file = at;

silent = true;

at = ReadCompiledWord(file, word);

}

if (!stricmp(word, (char*)"exit"))

{

file = at;

exitrequest = true;

}

FILE* in = FopenReadNormal(file); // source

if (!in)

{

(*printer)((char*)"No regression data found for %s\r\n", file);

return;

}

sprintf(logFilename, (char*)"%s/tmpregresslog.txt", usersfolder); // user log goes here so we can regenerate a new regression file if we need one

FILE* out = FopenUTF8Write(logFilename); // make a new log file to do this in.

FClose(out);

int olduserlog = userLog;

userLog = FILE_LOG;

unsigned int changed = 0;

bool modified = false;

bool oldecho = echo;

echo = false;

unsigned int count = 0;

prepareMode = REGRESS_MODE;

size_t len;

unsigned int minorchange = 0;

char* verifyinfo = AllocateBuffer();

unsigned int volley = 0;

char* myBuffer = AllocateBuffer();

char* buffer = AllocateBuffer();

regression = REGRESS_REGRESSION;

char* holdmain = ourMainOutputBuffer;

while (ReadALine(myBuffer, in) >= 0) // read regression file

{

//Respond: user:fd bot:rose volley:1 topic:~hellold input: what is your name output: My name is Rose. What's yours?

// verify: rule:~hello.4.0=MYNAME. kind:t label:MYNAME pattern: ( ) output: My name is Rose. $begintime = %fulltime ^^if ( ! $

// verify2: what is your name? rule:~physical_self.101.0=TELLNAME kind:u label:TELLNAME pattern: ( ![ him my her them ] << what your [ name moniker output: ^reuse ( ~hello.myname ) `01b u: ( !my what * you

if (!*myBuffer) continue;

char* ptr = SkipWhitespace(myBuffer);

if (*ptr == '#' || !*ptr) continue;

if (strstr(ptr, (char*)":quit")) break; // assume done

if (strstr(ptr, (char*)":trace"))

{

trace = (trace == (unsigned int)-1) ? 0 : -1;

echo = (trace != 0);

continue;

}

char user[MAX_WORD_SIZE];

char* u = strstr(ptr, (char*)"user:");

if (!u)

{

FreeBuffer();

FreeBuffer();

FreeBuffer();

ReportBug("Inconsistent regression file");

return;

}

u += 5;

ptr = ReadCompiledWord(u, user);

char bot[MAX_WORD_SIZE];

u = strstr(myBuffer, (char*)"bot:") + 4;

ptr = ReadCompiledWord(u, bot);

ptr = strchr(ptr, '(');

char topic[MAX_WORD_SIZE];

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

*end = 0;

ptr = ReadCompiledWord(ptr + 1, topic); // now points to volley

*end = ')';

char volleyid[MAX_WORD_SIZE];

ptr = ReadCompiledWord(ptr + 1, volleyid); // volley id

char* vinput = ptr;

char* oldsaid = strstr(vinput, (char*)"==> ");

char actualOutput[MAX_WORD_SIZE];

strcpy(actualOutput, oldsaid + 4);

*oldsaid = 0;

if (*(oldsaid - 1) == ' ') *(oldsaid - 1) = 0;

if (*(oldsaid - 2) == ' ') *(oldsaid - 2) = 0;

oldsaid += 4;

oldsaid = TrimSpaces(oldsaid, true);

// EXECUTE the input choice

ourMainOutputBuffer = buffer;

*buffer = 0;

// bot login

strcpy(computerID, bot);

*computerIDwSpace = ' ';

MakeLowerCopy(computerIDwSpace + 1, computerID);

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

strcpy(loginID, user); // user login

if (*myBuffer == 'S' || myBuffer[3] == 'S') // start it - 1st line may have utf8 marker

{

int depth = globalDepth; // reset clears depth, but we are still in process so need to restore it

int turn = atoi(volleyid);

if (turn == 0) ResetUser(vinput); // force reset

globalDepth = depth;

*vinput = 0;

userFirstLine = volleyCount + 1;

*readBuffer = 0;

originalUserInput = "";

AddInput("", 0, true);

ProcessInput();

FinishVolley(buffer, NULL);

char* revised = Purify(buffer);

if (revised != buffer) strcpy(buffer, revised);

TrimSpaces(buffer, false);

if (!responseIndex)

{

Log(ECHOUSERLOG, (char*)"*** No response to startup\r\n");

}

}

else if (*myBuffer == 'R' || myBuffer[3] == 'R')// respond - 1st line may have utf8 marker

{

int depth = globalDepth; // reset clears depth, but we are still in process so need to restore it

++volley;

ReadUserData();

char myinput[MAX_WORD_SIZE];

strcpy(myinput, vinput);

globalDepth = depth;

originalUserInput = myinput;

AddInput(myinput, 0, true);

ProcessInput();

int baseindex = bufferIndex;

FinishVolley(buffer, NULL);

bufferIndex = baseindex; // resettopreser cleared it

char* revised = Purify(buffer);

if (revised != buffer) strcpy(buffer, revised);

TrimSpaces(buffer, false);

if (!responseIndex)

{

Log(ECHOUSERLOG, (char*)"*** No response to user input\r\n");

}

}

else

{

Log(USERLOG, "Bad regression file lineup %s\r\n", myBuffer);

continue;

}

++count;

// now get verification data

ReadALine(readBuffer, in);

strcpy(verifyinfo, readBuffer); // copy so we can debug seeing original data

// verify: rule:~hello.1.0. kind:t label: pattern: ( !$olduser =8%input=0 =7%hour<12 ) output: $olduser = 1 Good morning. $begintime = %fulltime

char* vverify = strstr(verifyinfo, (char*)"verify: ") + 8;

ptr = strstr(vverify, (char*)"rule:");

*ptr = 0; // end of verification level

ptr += 5;

char vtag1[MAX_WORD_SIZE];

ptr = ReadCompiledWord(ptr, vtag1);

ptr = strstr(ptr, (char*)"kind:") + 5;

char vkind = *ptr;

char* vlabel = strstr(ptr, (char*)"label:") + 6;

char* vpattern = strstr(vlabel, (char*)"pattern: ");

*--vpattern = 0;

vpattern += 10;

char* equal = strchr(vtag1, '=');

if (equal) *equal = 0; // remove label from tag

char* voldoutputcode = strstr(vpattern, (char*)"output: "); // what it said then.

*--voldoutputcode = 0;

voldoutputcode += 9;

len = strlen(voldoutputcode);

while (voldoutputcode[len - 1] == ' ') --len;

voldoutputcode[len] = 0;

at = strchr(voldoutputcode, '`');

if (at) *at = 0;

bool sametag = false;

bool sameruletype = false;

bool samelabel = false;

bool samepattern = false;

bool sameoutput = false; // used same rule

char tag[MAX_WORD_SIZE];

int id = 0;

int topicid = 0;

char label[MAX_WORD_SIZE];

*label = 0;

char pattern[MAX_WORD_SIZE];

char outputdata[MAX_WORD_SIZE];

for (int i = 0; i < responseIndex; ++i) // use last said as topicid (we usually prefix emotions and other things)

{

// get actual results

unsigned int order = responseOrder[i];

strcpy(tag, GetTopicName(responseData[order].topic));

strcat(tag, responseData[order].id);

GetVerify(tag, topicid, id);

char* rule = GetRule(topicid, id); // the rule we want to test

char* newoutputcode = GetPattern(rule, label, pattern);

len = strlen(newoutputcode);

if (len > 50) len = 50;

strncpy(outputdata, newoutputcode, len);

while (outputdata[len - 1] == ' ') --len;

outputdata[len] = 0;

char* close = strchr(outputdata, '`');

if (close) *close = 0; // end rule

pattern[50] = 0; // limit it

if (!sametag) sametag = !strnicmp(tag, vtag1, strlen(vtag1));

if (!sameruletype) sameruletype = vkind == *rule;

if (!samelabel) samelabel = *label && !stricmp(label, vlabel);

if (!samepattern) samepattern = !stricmp(pattern, vpattern);

if (!sameoutput) sameoutput = !stricmp(outputdata, voldoutputcode); // used same rule

}

bool samesaid = !stricmp(oldsaid, buffer);

if (!samesaid && strstr(oldsaid, buffer)) samesaid = true; // see if we subsume what was said

char changes[MAX_WORD_SIZE];

*changes = 0;