#include "common.h"

extern int ignoreRule;

static bool down_is = true;

static int downcount = 0;

static int volleyCounter = 0;

static int relevantVolleyCounter = 0;

static int itemcount = 0;

bool nomixedcase = false;

void InitStats()

{

preparationtime = 0;

replytime = 0;

timerCheckInstance = 0;

modifiedTraceVal = 0;

modifiedTrace = false;

modifiedTimingVal = 0;

modifiedTiming = false;

rulesExecuted = 0;

wordAccessCount = 0;

bucketDepthCount = 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 || !stricmp(GetUserVariable("$bwtrace"), 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 (ALWAYS)

{

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 (ValidMemberFact(F))

{

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 (ValidMemberFact(F))

{

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

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

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

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

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 (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, true);

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

AddInput(input, 0,true);

char prepassTopic[MAX_WORD_SIZE];

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

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

while ((input = GetNextInput()))

{

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

oobstart = false;

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

for (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", mainOutputBuffer);

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

if (value && *value)

{

input = ptr;

int64 val64 = 0;

ReadInt64(value, val64);

tokenControl = val64;

}

}

AddInput(input, 0, true);

char* ptr = mainOutputBuffer;

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 (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", mainOutputBuffer);

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;

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.

char kind[MAX_WORD_SIZE];

ReadCompiledWord(readBuffer,kind);

if (!strstr(kind,(char*)"Respond:") && !strstr(kind,(char*)"Start:") ) 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)

{

if (volley || *kind != 'S')

{

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", kind, 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();

regression = REGRESS_REGRESSION;

char* holdmain = mainOutputBuffer;

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

{

//Start: user:fd bot:rose rand:553 volley:0 topic:~hello input: output: Good morning.

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

// verify2: rule:~submain_control.5.0 kind:u label: pattern: ( =8%input<%userfirstline ) output: $repeatstart = %userfirstline + 10 ^gambit ( ~hell

//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();

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

char* buffer = AllocateBuffer();

mainOutputBuffer = buffer;

// 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();

FinishVolley(buffer,NULL);

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;

if (!sametag) strcat(changes,(char*)"Tag, ");

if (!sameruletype) strcat(changes,(char*)"Rule type, ");

if (!samelabel && (*label || *vlabel)) strcat(changes,(char*)"Label, ");