// ChatScriptIDE.cpp : Defines the entry point for the application.

//

#include "stdafx.h"

#include "ChatScriptIDE.h"

#include <string>

#include <WindowsX.h>

#include "../SRC/common.h"

using namespace std;

/* entry points:

DebugCall

DebugAction

DebugVar

DebugMessage

DebugMark

*/

typedef struct WINDOWSTRUCT

{

HWND window;

int linesPerPage;

int charsPerPage;

int maxLines;

int maxChars;

RECT rect;

SIZE metrics;

int xposition;

int yposition;

} WINDOWSTRUCT;

WINDOWSTRUCT scriptData, statData, varData, sentenceData, stackData, inputData, outputData;

#define NO_BREAK 0

#define BREAK_CALL 1

#define BREAK_ACTION 2

#define BREAK_VAR 3

#define BREAK_MSG 4

typedef struct MAPDATA

{

uint64 botid; // restriction if any

MAPDATA* next; // maps are kept in order start to finish of a file,

char* filename;

int fileline;

char* name;

} MAPDATA;

typedef struct LINEDATA

{

LINEDATA* next;

LINEDATA* prior;

MAPDATA* mapentry;

char text[1]; // actually it can be any size

} LINEDATA;

typedef struct FILEDATA

{

FILEDATA* next;

char* filename;

LINEDATA* filelines; // actually, char*, char*, linecharacters

MAPDATA* map; // start of map info on this file

char* status;

int charsize;

int lineCount;

} FILEDATA;

typedef struct CLICKLIST

{

FILEDATA* file;

CLICKLIST* next;

int yposition;

int mousey;

} CLICKLIST;

static void UpdateWindowMetrics(WINDOWSTRUCT& data, bool font = false);

CLICKLIST* clickList = NULL;

static void AddTab(char* name);

FILEDATA* currentFileData = NULL;

static int offsetCode = -1;

int breakType = NO_BREAK;

static bool WhereAmI(int depth);

static char breakAt[400][40];

static int rulesInMap = 0;

static int rulesExecuted = 0;

static int breakIndex = 0;

int sentenceMode = 0;

static bool sysfail = false;

static int nextdepth = -1;

static int nextlevel = -1;

static int idedepth = -1;

static int ideoutputlevel = -1;

static char* fnvars = NULL;

static int fnlevel = -1;

static void ClearStops();

static uintptr_t csThread = 0;

static MAPDATA* lastItem = NULL;

static char filenames[1000];

static char varnames[1000];

static char varbreaknames[1000];

static MAPDATA* firstMap = NULL;

static MAPDATA* priorMapLine = NULL;

static char* DebugInput(char* input);

static void MakeCurrentFile(char* name, uint64 botid);

static char windowTitle[MAX_WORD_SIZE];

static int breakpointCount = 0;

static FILEDATA* fileList = NULL;

static char varAt[100][40];

static int varIndex = 0;

LINEDATA* firstline = NULL;

LINEDATA* priorline = NULL;

LINEDATA* line = NULL;

int outlevel = 0;

#define MAX_LOADSTRING 100

#define ID_EDITCHILD 100 // output

#define ID_EDITCHILD1 101 // input

HWND hParent = NULL;

static void RemoveBreak(char* name);

HWND hGoButton, hStopButton, hClearButton, hNextButton, hInButton, hOutButton;

HWND hLocalsButton, hBackButton, hBreakMessageButton;

HWND hFontButton, hFailButton;

HWND hDialog;

int fontsize = 30;

size_t editLen = 0;

bool changingEdit = false;

SCROLLINFO si;

static int ProcessBreak(char* input, int flags);

HFONT hFont, hFontBigger, hButtonFont;

HPEN hPen;

HBRUSH hBrush;

HBRUSH hBrushBlue;

HBRUSH hBrushOrange;

int mouseLine = -1;

int codeLine = -1; // where are we

FILEDATA* codeFile = NULL;

int codeOffset = -1;

char* codePtr = NULL;

int mouseCharacter = -1;

char transientBreak[200];

RECT titlerect;

RECT numrect;

RECT tagrect;

static char* DebugVar(char* name, char* value);

static char* DebugMark(char* name, char* value);

int outdepth = -1;

static char* DebugOutput(char* output);

// Global Variables:

HINSTANCE hInst; // current instance

char szTitle[MAX_LOADSTRING]; // The title bar text

char szWindowClass[MAX_LOADSTRING]; // the main scriptData.window class name

char* DoneCallback(char* buffer);

// Forward declarations of functions included in this code module:

ATOM MyRegisterClass(HINSTANCE hInstance, LPCSTR szWindowClass);

BOOL InitInstance(HINSTANCE, int);

LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);

INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);

static FILEDATA* GetFile(char* name, uint64 botid);

int APIENTRY wWinMain(_In_ HINSTANCE hInstance,

_In_opt_ HINSTANCE hPrevInstance,

_In_ LPWSTR lpCmdLine,

_In_ int nCmdShow)

{

UNREFERENCED_PARAMETER(hPrevInstance);

UNREFERENCED_PARAMETER(lpCmdLine);

if (!SetCurrentDirectory((LPCSTR)".."))

{

printf("no change dir");

}

// TODO: Place code here.

// Initialize global strings

LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);

LoadString(hInstance, IDC_CHATSCRIPTIDE, szWindowClass, MAX_LOADSTRING);

ATOM j = MyRegisterClass(hInstance, (LPCSTR)szWindowClass);

// Perform application initialization:

if (!InitInstance(hInstance, nCmdShow))

{

return FALSE;

}

HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_CHATSCRIPTIDE));

MSG msg;

// Main message loop:

while (GetMessage(&msg, nullptr, 0, 0))

{

if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))

{

TranslateMessage(&msg);

DispatchMessage(&msg);

}

}

return (int)msg.wParam;

}

static MAPDATA* FindFileMap(char* filename, uint64 botid)

{

MAPDATA* at = firstMap;

while (at)

{

// map has link, file, line, name

// we match either full path or tail naming only

if ((at->botid == botid || at->botid & botid) &&

(!stricmp(at->name, filename) || !stricmp(at->filename, filename)))

{

return at;

}

at = at->next; // use forward ptr

}

return NULL;

}

static MAPDATA* FindLine(int line)

{

return NULL;

}

static void ReadWindow(HWND window, FILE* in)

{

char buffer[500];

ReadALine(buffer, in);

char* data = buffer;

char word[MAX_WORD_SIZE];

data = ReadCompiledWord(data, word);

data = ReadCompiledWord(data, word);

int x = atoi(word);

data = ReadCompiledWord(data, word);

int y = atoi(word);

data = ReadCompiledWord(data, word);

int z = atoi(word);

data = ReadCompiledWord(data, word);

int q = atoi(word);

MoveWindow(window, x, y, z, q, true);

}

static void RestoreWindows()

{

FILE* in = FopenReadOnly("idesettings.txt");

if (!in) return;

ReadWindow(scriptData.window, in);

UpdateWindowMetrics(scriptData, true);

ReadWindow(inputData.window, in);

ReadWindow(outputData.window, in);

UpdateWindowMetrics(outputData, true);

ReadWindow(statData.window, in);

UpdateWindowMetrics(statData, true);

ReadWindow(varData.window, in);

UpdateWindowMetrics(varData, true);

ReadWindow(stackData.window, in);

UpdateWindowMetrics(stackData, true);

ReadWindow(hGoButton, in);

ReadWindow(hInButton, in);

ReadWindow(hOutButton, in);

ReadWindow(hNextButton, in);

ReadWindow(hStopButton, in);

ReadWindow(hBreakMessageButton, in);

ReadWindow(hClearButton, in);

ReadWindow(hLocalsButton, in);

ReadWindow(hBackButton, in);

ReadWindow(hFontButton, in);

ReadWindow(hFailButton, in);

char buffer[100];

ReadALine(buffer, in);

fontsize = atoi(buffer + 10);

fclose(in);

}

static void SaveWindow(HWND window, char* name, FILE* out)

{

RECT rect;

GetWindowRect(window, &rect);

fprintf(out, "%s: %d %d %d %d \r\n", name, rect.left, rect.top, rect.right, rect.bottom);

}

static void SaveWindows()

{

FILE* out = FopenBinaryWrite("idesettings.txt");

if (!out) return;

SaveWindow(scriptData.window, "script", out);

SaveWindow(inputData.window, "input", out);

SaveWindow(outputData.window, "output", out);

SaveWindow(statData.window, "statistics", out);

SaveWindow(varData.window, "variables", out);

SaveWindow(stackData.window, "stack", out);

SaveWindow(hGoButton, "go", out);

SaveWindow(hInButton, "in", out);

SaveWindow(hOutButton, "out", out);

SaveWindow(hNextButton, "next", out);

SaveWindow(hStopButton, "stop", out);

SaveWindow(hBreakMessageButton, "msgbreak", out);

SaveWindow(hClearButton, "clear", out);

SaveWindow(hLocalsButton, "locals", out);

SaveWindow(hBackButton, "back", out);

SaveWindow(hFontButton, "font", out);

SaveWindow(hFailButton, "fail", out);

fprintf(out, "fontsize: %d\r\n", fontsize);

fclose(out);

}

static void DumpMaps()

{

FILE* out = FopenBinaryWrite("tmp/tmp.txt");

MAPDATA* map = firstMap;

while (map)

{

fprintf(out, "%d %s %s\r\n", map->fileline, map->filename, map->name);

map = map->next;

}

fclose(out);

}

static MAPDATA* FindMap(char* name, char* filename)

{

MAPDATA* at = firstMap;

char* oldname = NULL;

while (at)

{

if (at->filename != oldname)

{

oldname = at->filename;

Log(STDDEBUGLOG, "%s\r\n", oldname);

}

char* entry = at->name; // map has link, file, line, name

if (filename && stricmp(at->filename, filename)) { ; }

else

{

if (*entry == '^' || *entry == '~') priorMapLine = at;

if (!stricmp(name, entry))

return at;

}

at = at->next; // use forward ptr

}

return NULL;

}

static MAPDATA* FindLabelMap(char* label, uint64 botid)

{

MAPDATA* at = firstMap;

while (at)

{

// map has link, file, line, name

// we match either full path or tail naming only

if ((at->botid == botid || at->botid & botid) &&

*at->name == '~')

{

char* hyphen = strchr(at->name, '-');

if (hyphen && strchr(at->name, '.')) // tag + label

{

if (!stricmp(hyphen + 1, label))

return at;

}

}

at = at->next; // use forward ptr

}

return NULL;

}

static void DefineVertScroll(WINDOWSTRUCT& data, int pos)

{

if (!data.window) return;

si.fMask = SIF_POS | SIF_RANGE;

if (pos >= 0) si.nPos = pos;

si.nMin = 0;

si.nMax = data.maxLines;

SetScrollInfo(data.window, SB_VERT, &si, true);

InvalidateRgn(data.window, NULL, true);

}

static char* ShowActions(char* actions, int level)

{

static char src[100];

sprintf(src, "lvl:%d ", level);

char* at = src + strlen(src);

strncpy(at, actions, 40);

at[40] = 0;

at = strchr(at, '`');

if (at) *at = 0;

return src;

}

static char* GetDefn(int depth)

{

CALLFRAME* frame = GetCallFrame(depth);

if (*frame->label != '^') return NULL; // not a callframe

char* definition = frame->definition;

if (!definition) return NULL;

return ++definition; // ( xxx xxx )

}

static void StackVariables(int depth)

{

fnvars = 0;

fnlevel = -1;

if (depth <= 0 || depth > globalDepth) return;

fnvars = GetDefn(depth);

sprintf(windowTitle, "local variables");

SetWindowText(varData.window, (LPCTSTR)windowTitle);

fnlevel = depth;

// now at "(xxx xxx xxx )" argument list + locals

}

static void BackClick()

{

if (!clickList) return;

CLICKLIST* click = clickList;

clickList = click->next;

mouseLine = click->mousey;

scriptData.yposition = click->yposition;

}

static void AddClick()

{

// already there

if (clickList && clickList->file == currentFileData &&

clickList->yposition == scriptData.yposition) return;

CLICKLIST* click = (CLICKLIST*)malloc(sizeof(CLICKLIST));

click->next = clickList;

clickList = click;

click->file = currentFileData;

click->yposition = scriptData.yposition;

click->mousey = mouseLine;

}

static void RestoreClick()

{

if (!clickList) return;

CLICKLIST* click = clickList;

clickList = clickList->next;

scriptData.yposition = click->yposition;

mouseLine = click->mousey;

currentFileData = click->file;

AddTab(click->file->filename);

scriptData.maxLines = currentFileData->lineCount;

scriptData.maxChars = currentFileData->charsize;

free(click);

InvalidateRgn(scriptData.window, NULL, true);

}

static void FreeClicklist()

{

while (clickList)

{

CLICKLIST* next = clickList->next;

free(clickList);

clickList = next;

}

}

static char* ChaseFnVariable(char* name, int mydepth)

{

if (globalDepth <= 0) return NULL; // not stopped in execution

int depth = (mydepth <= 0) ? 1 : mydepth; // go to current

char label[MAX_WORD_SIZE];

sprintf(label, "%s ", name);

CALLFRAME* frame = GetCallFrame(depth);

if (*name == '$') while (++depth <= globalDepth) // go deeper to see

{

frame = GetCallFrame(depth);

if (*frame->label == '~' && strchr(frame->label, '.')) continue;

char* defn = frame->definition;

if (!defn) continue;

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

*end = 0;

// find variable in list

char* found = strstr((char*)defn, label);

*end = ')';

if (!found) continue; // not used by this

// find which display arg it is

*found = 0;

int n = 0;

char* at = (char*)defn + 2;

char arg[MAX_WORD_SIZE];

while (*at)

{

at = ReadCompiledWord(at, arg);

if (*arg == USERVAR_PREFIX) ++n; // we dont count ^args

}

*found = *label;

// need the nth arg old display value

char* val = frame->display[n];

return (!*val) ? "null" : val;

}

if (*name == '^')

{

// find which display arg it is

char* defn = frame->definition;

if (!defn) return "null"; // not yet visible

char* at = (char*)defn + 2;

char arg[MAX_WORD_SIZE];

int n = 1; // ARGUMENT(1)

while (*at)

{

at = ReadCompiledWord(at, arg);

if (!stricmp(arg, name)) break;

++n;

if (n > frame->arguments) return "null"; // not there, may not have been even called

}

char* answer = callArgumentList[frame->varBaseIndex + n];

return answer;

}

return GetUserVariable(name); // current value is correct

}

static void DefineHorzScroll(WINDOWSTRUCT& data, int pos)

{

if (!data.window) return;

si.fMask = SIF_POS | SIF_RANGE;

if (pos >= 0) si.nPos = pos;

si.nMin = 0;

si.nMax = data.maxChars;

SetScrollInfo(data.window, SB_HORZ, &si, true);

InvalidateRgn(data.window, NULL, true);

}

static void ShowStack()

{

if (stackData.window) // compute scroll data for stack window

{

int maxchar = 0;

for (int i = 1; i <= globalDepth; ++i)

{

CALLFRAME* frame = GetCallFrame(i);

size_t len = strlen(frame->label);

if (len > maxchar) maxchar = len;

}

stackData.maxChars = maxchar;

stackData.maxLines = globalDepth;

stackData.xposition = 0;

if (globalDepth > stackData.linesPerPage)

stackData.yposition = globalDepth - stackData.linesPerPage;

DefineVertScroll(stackData, stackData.yposition);

DefineHorzScroll(stackData, 0);

InvalidateRgn(stackData.window, NULL, true);

StackVariables(globalDepth);

InvalidateRgn(varData.window, NULL, true);

}

}

static void ShowVariables()

{

if (varData.window) InvalidateRgn(varData.window, NULL, true);

}

char* DoneCallback(char* buffer)

{

sprintf(windowTitle, "%s=>%s (%I64u)", loginID, computerID, myBot);

SetWindowText(scriptData.window, (LPCTSTR)windowTitle);

ShowVariables();

stackData.maxLines = 0;

stackData.maxChars = 0;

DefineVertScroll(stackData, 0);

DefineHorzScroll(stackData, 0);

// no reason to update stack window, we have finished volley

return buffer;

}

static void UpdateWindowMetrics(WINDOWSTRUCT& data, bool font)

{

HDC dc = GetDC(data.window);

if (font) SelectObject(dc, hFontBigger);

else SelectObject(dc, hFont);

GetTextExtentPoint32(dc, (LPCTSTR)"12TzqbABCDEFGHIJKLMNOPQRSTUVWXYZ", 32, &data.metrics);

ReleaseDC(data.window, dc);

data.metrics.cx /= 32;

data.metrics.cx += 1;

data.charsPerPage = ((data.rect.right - data.rect.left) / data.metrics.cx) - 1;

data.linesPerPage = ((data.rect.bottom - data.rect.top) / data.metrics.cy);

si.fMask = SIF_RANGE | SIF_PAGE;

si.nPage = data.charsPerPage;

si.nMin = 0;

si.nMax = data.maxChars;

SetScrollInfo(data.window, SB_HORZ, &si, false);

// we can display this many lines

si.nPage = data.linesPerPage;

si.nMin = 0;

si.nMax = data.maxLines;

SetScrollInfo(data.window, SB_VERT, &si, false);

}

static void UpdateMetrics()

{

UpdateWindowMetrics(scriptData);

scriptData.rect.top = scriptData.metrics.cy;

titlerect.bottom = scriptData.metrics.cy;

InvalidateRgn(scriptData.window, NULL, true);

if (varData.window)

{

UpdateWindowMetrics(varData);

InvalidateRgn(varData.window, NULL, true);

}

if (outputData.window)

{

UpdateWindowMetrics(outputData);

InvalidateRgn(outputData.window, NULL, true);

}

if (statData.window)

{

UpdateWindowMetrics(statData);

InvalidateRgn(statData.window, NULL, true);

}

if (stackData.window)

{

UpdateWindowMetrics(stackData);

InvalidateRgn(stackData.window, NULL, true);

}

}

void EraseVariable(int which)

{

if (!*varnames) return;

char* var = varnames;

size_t len;

char name[MAX_WORD_SIZE];

char* end;

while (*var)

{

// get next variable name

end = strstr(var, "\r\n");

if (!end) break; *end = 0;

if (which-- == 0) break;

*end = '\r';

var = end + 2;

}

ReadCompiledWord(var, name);

if (end) *end = '\r';

char junk[MAX_WORD_SIZE];

sprintf(junk, "%s\r\n", name);

char* found = strstr(varnames, junk);

if (!found) return;

len = strlen(name);

--varData.maxLines;

char* after = found + len + 2;

memmove(found, after, strlen(after) + 2); // remove name

}

static void VerifyMap()

{

FILEDATA* file = fileList;

int count = 0;

bool found = false;

while (file)

{

LINEDATA* fileLines = file->filelines;

while (fileLines)

{

MAPDATA* map = fileLines->mapentry;

if (map->name && (map->name, "control.9")) found = true;

++count;

fileLines = fileLines->next;

}

file = file->next;

}

if (found)

{

int xx = 0;

}

else

{

int xx = 0;

}

}

static void DoBreakVariable(int which)

{

if (!*varnames && !fnvars)

{

return;

}

char* var = (fnvars) ? fnvars : varnames;

size_t len;

char name[MAX_WORD_SIZE];

char* end;

while (*var)

{

// get next variable name

end = strstr(var, "\r\n");

if (!end) end = strstr(var, " "); // fnvars

if (!end) end = strstr(var, ")"); // fnvars

if (!end) break;

*end = 0;

if (which-- == 0) break;

*end = '\r';

var = end + 2;

}

ReadCompiledWord(var, name);

if (*name == '^')

{

DebugPrint("cannot breakpoint a ^var\r\n");

return; // cannot break on ^var

}

if (end) *end = '\r';

char junk[MAX_WORD_SIZE];

sprintf(junk, "%s\r\n", name);

char* found = strstr(varbreaknames, junk);

len = strlen(name);

if (found) // remove name from existing list

{

char* after = found + len + 2;

memmove(found, after, strlen(after) + 2); // remove name

if (!*varbreaknames) debugVar = NULL;

return;

}

// insert at start of list

memmove(varbreaknames + len + 2, varbreaknames, strlen(varbreaknames) + 1);

memmove(varbreaknames, name, len);

varbreaknames[len] = '\r';

varbreaknames[len + 1] = '\n';

debugVar = DebugVar;

}

static void AddVariable(char* name)

{

char junk[MAX_WORD_SIZE];

sprintf(junk, "%s\r\n", name);

MakeLowerCase(junk);

char* found = strstr(varnames, junk);

size_t len = strlen(name);

if (found) // remove name from existing list

{

--varData.maxLines;

char* after = found + len + 2;

memmove(found, after, strlen(after) + 2); // remove name

}

// insert at start of list

memmove(varnames + len + 2, varnames, strlen(varnames) + 1);

memmove(varnames, junk, len);

varnames[len] = '\r';

varnames[len + 1] = '\n';

++varData.maxLines;

DefineVertScroll(varData, 0);

if (*loginID && !csThread) ReadUserData(); // but not if suspended or unstarted

ShowVariables();

if (!csThread) ResetToPreUser();// but not if suspended

}

static int NameLine(char* name)

{

MAPDATA* symbol = FindMap(name, NULL); // find name in any file

if (!symbol) return -1;

char* file = symbol->filename;

MakeCurrentFile(file, symbol->botid);

return symbol->fileline;

}

uint64 FindBotID(char* name)

{

char id[MAX_WORD_SIZE];

MakeLowerCopy(id, name);

strcat(id, "`bot");

MAPDATA* at = firstMap;

while (at)

{

char* entry = at->name; // map has link, file, line, name

if (!stricmp(id, entry))

return at->botid;

at = at->next; // use forward ptr

}

return (uint64)(int64)-1;

}

static void RemoveTab(char* name)

{

char fullname[1000];

sprintf(fullname, " %s ", name);

char* found = strstr(filenames, fullname);

size_t len = strlen(fullname);

if (found) // remove short name + space from existing list

{

char* after = found + len - 1;

memmove(found, after, strlen(after) + 1); // remove name

if (filenames[1] == ' ') // if it was leader, change leader

{

memmove(filenames, filenames + 1, strlen(filenames) + 1);

char word[MAX_WORD_SIZE];

ReadCompiledWord(filenames, word);

AddTab(word); // reinsert properly

}

InvalidateRgn(scriptData.window, NULL, true);

}

}

static void AddTab(char* name)

{

RemoveTab(name);

size_t len = strlen(name);

// remove 2 extra spaces on separator, make single space

char old[1000];

char* triple = strstr(filenames, " ");

if (triple)

{

strcpy(old, triple + 4);

strcpy(triple + 1, old);

}

strcpy(old, filenames);

*filenames = ' ';

strcpy(filenames + 1, name);

strcat(filenames, " ");

if (*old) strcat(filenames, old + 1); //leave off extra space

}

MAPDATA* AlignName(char* name)

{

char namex[1000];

strcpy(namex, name);

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

if (at) *at = 0;

at = strchr(namex, '{');

if (at) *at = 0;

MAPDATA* symbol = FindMap(namex, NULL); // find name in any file

if (!symbol)symbol = FindLabelMap(namex, NULL);

if (!symbol) return NULL;

char* file = symbol->filename;

FILEDATA* oldfile = currentFileData;

AddClick();

MakeCurrentFile(file, symbol->botid);

mouseLine = symbol->fileline; // 1-based, whereas yposition is 0-based

mouseCharacter = 0;

scriptData.maxLines = currentFileData->lineCount;

scriptData.maxChars = currentFileData->charsize;

if (oldfile != currentFileData)

{

scriptData.yposition = symbol->fileline - 3; // start with item showing in context

scriptData.xposition = 0; // reset

}

else if (mouseLine > (scriptData.yposition + 1 + scriptData.linesPerPage))

scriptData.yposition = symbol->fileline - 3; // start with item showing in context

else if (mouseLine < scriptData.yposition + 1)

scriptData.yposition = symbol->fileline - 3; // start with item showing in context

else if ((symbol->fileline - scriptData.yposition - 1) < (scriptData.yposition + scriptData.linesPerPage)) { ; } // same page

else if (currentFileData->lineCount > scriptData.maxLines)

scriptData.yposition = symbol->fileline - 3; // start with item showing in context

else scriptData.yposition = 0;

if (scriptData.yposition < 0) scriptData.yposition = 0; // file name must not back up

DefineVertScroll(scriptData, scriptData.yposition);

scriptData.maxChars = currentFileData->charsize;

DefineHorzScroll(scriptData, 0);

return symbol;

}

void FindBot(char* name)

{

myBot = -1; // all access pass

if (name) // happens when we have logged in and gotten a bot

{

AlignName(name);

myBot = FindBotID(name);

sprintf(windowTitle, "%s=>%s (%I64u)", loginID, computerID, myBot);

SetWindowText(scriptData.window, (LPCTSTR)windowTitle);

return;

}

// happens on startup before login has occured

if (*defaultbot)

{

AlignName(defaultbot);

myBot = FindBotID(defaultbot);

sprintf(windowTitle, "%s=>%s (%I64u)", "", defaultbot, myBot);

SetWindowText(scriptData.window, (LPCTSTR)windowTitle);

return;

}

WORDP D = FindWord("defaultbot");

FACT* F = GetVerbNondeadHead(D);

while (F)

{

if (F->verb == F->object)

{

char name[MAX_WORD_SIZE];

D = Meaning2Word(F->subject);

sprintf(name, "^%s", D->word);

AlignName(name);

myBot = FindBotID(name);

sprintf(windowTitle, "%s=>%s (%I64u)", "", name, myBot);

SetWindowText(scriptData.window, (LPCTSTR)windowTitle);

break;

}

F = GetVerbNondeadNext(F);

}

}

//

// FUNCTION: MyRegisterClass()

//

// PURPOSE: Registers the scriptData.window class.

//

ATOM MyRegisterClass(HINSTANCE hInstance, LPCSTR szWindowClass)

{

WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_HREDRAW | CS_VREDRAW;

wcex.lpfnWndProc = WndProc;

wcex.cbClsExtra = 0;

wcex.cbWndExtra = 0;

wcex.hInstance = hInstance;

wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_CHATSCRIPTIDE));

wcex.hCursor = LoadCursor(nullptr, IDC_ARROW);

wcex.hbrBackground = (HBRUSH)(COLOR_WINDOW + 1);

wcex.lpszMenuName = MAKEINTRESOURCE(IDC_CHATSCRIPTIDE);

wcex.lpszClassName = szWindowClass;

wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));

return RegisterClassEx(&wcex);

}

static char* GetStartCharacter(LINEDATA* line)

{

if (!line) return NULL;

char* msg = (char*)&line->text;

if (scriptData.xposition)

{

int count = scriptData.xposition;

while (count-- && *msg) ++msg;

}

return msg;

}

static LINEDATA* GetStartLine(int count)

{

if (!currentFileData) return NULL;

LINEDATA* at = currentFileData->filelines;

if (count)

{

while (count-- && at) at = at->next; // use forward ptr

}

return at;

}

static MAPDATA* MapAllocate(uint64 botid, char* file, char* name, char* line)

{

size_t len = strlen(name);

MAPDATA* map = (MAPDATA*)malloc(sizeof(MAPDATA)); // link, file, line, name

map->next = NULL; // forward link

map->botid = botid;

map->filename = file; // set file name

map->fileline = (line) ? atoi(line) : 0; // set line number

// when name is a number (line number) or if/else/loop then line is an offset into block or rule data

// rule: ~medical_glean.43.0-MEDICALBODYPARTKIND u: 246

char* x = (char*)malloc(len + 1);

strcpy(x, name);

map->name = x;

if (!firstMap) firstMap = map; // ordered

if (priorMapLine) priorMapLine->next = map; // set old forward ptr

priorMapLine = map;

return map;

}

static LINEDATA* ReadFile(char* name, size_t& maxchars, int& maxlines, uint64 botid)

{

FILE* in = fopen(name, "rb");

if (!in) return NULL;

char buffer[20000];

firstline = NULL;

priorline = NULL;

line = NULL;

maxlines = 0;

maxchars = 0;

MAPDATA* map = FindFileMap(name, botid); // get map for this

if (!map)

{

fclose(in);

return NULL;

}

int currentMapLine = map->fileline;

while (fgets(buffer, 20000, in)) // make linked list of all text

{

++maxlines;

char* at = buffer;

while ((at = strchr(at, '\t')))