#include "stdafx.h"

#include "ChatScriptIDE.h"

#include <string>

#include <WindowsX.h>

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

using namespace std;

typedef struct WINDOWSTRUCT

} 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

} MAPDATA;

typedef struct LINEDATA

} LINEDATA;

typedef struct FILEDATA

} FILEDATA;

typedef struct CLICKLIST

} 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);

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

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,

}

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)

}

static void RestoreWindows()

}

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

}

static void SaveWindows()

}

static void DumpMaps()

}

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)

}

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)

}

static void BackClick()

}

static void AddClick()

}

static void RestoreClick()

}

static void FreeClicklist()

}

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)

}

static void ShowStack()

}

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)

}

static void UpdateMetrics()

}

void EraseVariable(int which)

}

static void VerifyMap()

}

static void DoBreakVariable(int which)

}

static void AddVariable(char* name)

}

static int NameLine(char* name)

}

uint64 FindBotID(char* name)

}

static void RemoveTab(char* name)

}

static void AddTab(char* name)

}

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)

}

ATOM MyRegisterClass(HINSTANCE hInstance, LPCSTR szWindowClass)

}

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')))