#include "common.h"

#ifdef INFORMATION

Function calls all run through DoCommand().

A function call can either be to a system routine or a user routine.

User routines are like C macros, executed in the context of the caller, so the argument

are never evaluated prior to the call. If you evaluated an argument during the mustering,

you could get bad answers. Consider:

One has a function: ^foo(^arg1 ^arg2) ^arg2 ^arg1

And one has a call ^foo(($val = 1 ) $val )

This SHOULD look like inline code: $val $val = 1

But evaluation at argument time would alter the value of $val and pass THAT as ^arg2. Wrong.

The calling Arguments to a user function are in an array, whose base starts at callArgumentBase and runs

up to (non-inclusive) callArgumentIndex.

System routines are proper functions, whose callArgumentList may or may not be evaluated.

The callArgumentList are in an array, whose base starts at index CallingArgumentBase and runs

up to (non-inclusive) CallingArgumentIndex. The description of a system routine tells

how many callArgumentList it expects and in what way. Routines that set variables always pass

that designator as the first (unevaluated) argument and all the rest are evaluated callArgumentList.

The following argument passing is supported

1. Evaluated - each argument is evaluated and stored (except for a storage argument).

If the routine takes optional callArgumentList these are already also evaluated and stored,

and the argument after the last actual argument is a null string.

2. STREAM_ARG - the entire argument stream is passed unevaled as a single argument,

allowing the routine to handle processing them itself.

All calls have a context of "executingBase" which is the start of the rule causing this

evaluation. All calls are passed a "buffer" which is spot in the currentOutputBase it

should write any answers.

Anytime a single argument is expected, one can pass a whole slew of them by making

them into a stream, encasing them with (). The parens will be stripped and the

entire mess passed unevaluated. This makes it analogous to STREAM_ARG, but the latter

requires no excess parens to delimit it.

Memory management:

Regular heap space is used to hold permanent data (e.g. variable assignment for non-local variables.

#endif

#define SIZELIM 200

#define MAX_TOPIC_KEYS 5000

#define PLANMARK -1

#define RULEMARK -2

#define MAX_LOG_NAMES 16

char* fnOutput = NULL;

char lognames[MAX_LOG_NAMES][200];

FILE* logfiles[MAX_LOG_NAMES];

char* codeStart = NULL;

char* realCode = NULL;

int rulesExecuted = 0;

bool planning = false;

#define MAX_REUSE_SAFETY 100

static int reuseIndex = 0;

static char* reuseSafety[MAX_REUSE_SAFETY+1];

static int reuseSafetyCount[MAX_REUSE_SAFETY+1];

static char* months[] = { (char*)"January",(char*)"February",(char*)"March",(char*)"April",(char*)"May",(char*)"June",(char*)"July",(char*)"August",(char*)"September",(char*)"October",(char*)"November",(char*)"December"};

static char* days[] = { (char*)"Sunday",(char*)"Monday",(char*)"Tuesday",(char*)"Wednesday",(char*)"Thursday",(char*)"Friday",(char*)"Saturday"};

long http_response = 0;

int globalDepth = 0;

int maxGlobalSeen = 0;

char* stringPlanBase = 0;

char* backtrackPoint = 0; // plan code backtrace data

unsigned int currentIterator = 0; // next value of iterator

unsigned int savedSentences = 0;

char* callArgumentList[MAX_ARGUMENT_COUNT+1]; // arguments to functions

int callArgumentBases[MAX_CALL_DEPTH]; // arguments to functions

WORDP callStack[MAX_CALL_DEPTH];

unsigned int callIndex = 0;

unsigned int callArgumentIndex;

int callArgumentBase;

int fnVarbase;

bool backtrackable = false;

char lastInputSubstitution[INPUT_BUFFER_SIZE];

TestMode wasCommand; // special result passed back from some commands to control chatscript

static char oldunmarked[MAX_SENTENCE_LENGTH];

static unsigned int spellSet; // place to store word-facts on words spelled per a pattern

char* currentPlanBuffer;

static int rhymeSet;

void InitFunctionSystem() // register all functions

}

unsigned char* GetDefinition(WORDP D)

{

unsigned char* defn = D->w.fndefinition; // raw definition w link

if (!defn) return NULL;

return defn + 4; // skip link field, leaves botid, flags , count

}

unsigned int MACRO_ARGUMENT_COUNT(unsigned char* defn) // 0e(

}

char* InitDisplay(char* list)

{

char word[MAX_WORD_SIZE];

list += 2; // skip ( and space

while (1)

{

list = ReadCompiledWord((char*)list, word);

if (*word == ')') break; // end of display is signaled by )

if (*word == USERVAR_PREFIX)

{

// printf("saving %s for %d %s\r\n", word, globalDepth, GetCallFrame(globalDepth)->label);

if (!AllocateStackSlot(word)) return 0;

}

}

return list;

}

void RestoreDisplay(char** base, char* list)

}

void ResetFunctionSystem()

}

#ifdef WIN32

#define MAKEWORDX(a, b) ((unsigned short)(((BYTE)(((DWORD_PTR)(a)) & 0xff)) | ((unsigned short)((BYTE)(((DWORD_PTR)(b)) & 0xff))) << 8))

FunctionResult InitWinsock()

}

#endif

static char* GetPossibleFunctionArgument(char* arg, char* word)

{

char* ptr = ReadCompiledWord(arg,word);

if (*word == '^' && IsDigit(word[1]))

{

char* value = FNVAR(word+1);

if (*value == LCLVARDATA_PREFIX && value[1] == LCLVARDATA_PREFIX)

value += 2; // already evaled data -- but bug remains

strcpy(word,value);

}

// this gets us what was passed by name, $xxx.hi will be a json ref.

return ptr;

}

FunctionResult JavascriptArgEval(unsigned int index, char* buffer)

}

char* SaveBacktrack(int id)

{

// save: id, oldbacktrack point, currentfact, current dict,

char* mark = AllocateHeap(NULL,4,sizeof(int),false);

if (!mark) return NULL;

int* i = (int*) mark;

i[0] = id; // 1st int is a backtrack label - plan (-1) or rule (other)

i[1] = (int)(stringPlanBase - backtrackPoint); // 2nd is old backtrack point value

i[2] = Fact2Index(factFree); // 4th is fact base

i[3] = Word2Index(dictionaryFree); // 5th is word base (this entry is NOT used)

return backtrackPoint = mark;

}

unsigned char* FindAppropriateDefinition(WORDP D, FunctionResult& result)

{

int64 botid;

unsigned char* defn = D->w.fndefinition; // raw definition w link

unsigned char* allaccess = NULL;

unsigned int link = (defn[0] << 24) + (defn[1] << 16) + (defn[2] << 8) + (defn[3]);

defn += 4; // skip jump

defn = (unsigned char*)ReadInt64((char*)defn, botid);

if (botid == 0) allaccess = defn; // default access

while (!(myBot & botid) && !compiling && link) // wrong bot, but have link to another bots can share code

{

if (!botid) allaccess = defn;

defn = (unsigned char*)Index2Heap(link); // next defn

link = (defn[0] << 24) + (defn[1] << 16) + (defn[2] << 8) + (defn[3]);

defn += 4; // skip jump

defn = (unsigned char*)ReadInt64((char*)defn, botid);

}

if (!botid && !myBot) {; } // matches

else if (compiling) {;} // during compilation most recent always matches

else if (!(myBot & botid)) defn = allaccess;

result = (!defn) ? FAILRULE_BIT : NOPROBLEM_BIT;

if (!defn) ReportBug((char*) "Function %s not found for bot",D->word)

return defn; // point at (

}

static char* FlushMark() // throw away this backtrack point, maybe reclaim its heap space

{

if (!backtrackPoint) return NULL;

// we are keeping facts and variable changes, so we cannot reassign the string free space back because it may be in use.

if (backtrackPoint == heapFree) heapFree = backtrackPoint + (4 * sizeof(int));

int* i = (int*) backtrackPoint;

return backtrackPoint = stringPlanBase - i[1];

}

static void RestoreMark()

}

void RefreshMark()

}

static void UpdatePlanBuffer()

}

static int WildStartPosition(char* arg)

}

static int WildEndPosition(char* arg)

}

static FunctionResult PlanCode(WORDP plan, char* buffer)

{ // failing to find a responder is not failure.

#ifdef INFORMATION

A plan sets a recover point for backtracking and clears it one way or another when it exits.

A rule sets a backpoint only if it finds some place to backtrack. The rule will clear that point one way or another when it finishes.

Undoable changes to variables are handled by creating special facts.

#endif

if (trace & (TRACE_MATCH|TRACE_PATTERN) && CheckTopicTrace()) Log(STDTRACELOG,(char*)"\r\n\r\nPlan: %s ",plan->word);

WORDP originalPlan = plan;

bool oldplan = planning;

bool oldbacktrackable = backtrackable;

char* oldbacktrackPoint = backtrackPoint;

char* oldStringPlanBase = stringPlanBase;

stringPlanBase = heapFree;

backtrackPoint = heapFree;

backtrackable = false;

unsigned int oldWithinLoop = withinLoop;

withinLoop = 0;

planning = true;

int holdd = globalDepth;

char* oldCurrentPlanBuffer = currentPlanBuffer;

unsigned int tindex = topicIndex;

FunctionResult result = NOPROBLEM_BIT;

ChangeDepth(1,originalPlan->word); // plancode

// where future plans will increment naming

char name[MAX_WORD_SIZE];

strcpy(name,plan->word);

char* end = name + plan->length;

*end = '.';

*++end = 0;

unsigned int n = 0;

while (result == NOPROBLEM_BIT) // loop on plans to use

{

*buffer = 0;

currentPlanBuffer = buffer; // where we are in buffer writing across rules of a plan

int topicid = plan->x.topicIndex;

if (!topicid)

{

result = FAILRULE_BIT;

break;

}

int pushed = PushTopic(topicid); // sets currentTopicID

if (pushed < 0)

{

result = FAILRULE_BIT;

break;

}

char* xxplanMark = SaveBacktrack(PLANMARK); // base of changes the plan has made

char* base = GetTopicData(topicid);

int ruleID = 0;

currentRuleTopic = currentTopicID;

currentRule = base;

currentRuleID = ruleID;

char* ruleMark = NULL;

bool fail = false;

CALLFRAME* frame = ChangeDepth(1,GetTopicName(currentTopicID)); // plancode

char* locals = GetTopicLocals(currentTopicID);

bool updateDisplay = locals && DifferentTopicContext(-1, currentTopicID);

frame->display = (char**)stackFree;

if (updateDisplay && !InitDisplay(locals)) fail = true;

while (!fail && base && *base ) // loop on rules of topic

{

currentRule = base;

ruleMark = SaveBacktrack(RULEMARK); // allows rule to be completely undone if it fails

backtrackable = false;

result = TestRule(ruleID,base,currentPlanBuffer); // do rule at base

if (!result || (result & ENDTOPIC_BIT)) // rule didnt fail

{

UpdatePlanBuffer(); // keep any results

if (result & ENDTOPIC_BIT) break; // no more rules are needed

}

else if (backtrackable) // rule failed

{

while (backtrackable)

{

if (trace & (TRACE_MATCH|TRACE_PATTERN) && CheckTopicTrace()) Log(STDTRACETABLOG,(char*)"Backtrack \r\n");

*currentPlanBuffer = 0;

RefreshMark(); // undo all of rule, but leave undo marker in place

backtrackable = false;

result = DoOutput(currentPlanBuffer,currentRule,currentRuleID); // redo the rule per normal

if (!result || result & ENDTOPIC_BIT) break; // rule didnt fail

}

if (result & ENDTOPIC_BIT) break; // rule succeeded eventually

}

FlushMark(); // cannot revert changes after this

base = FindNextRule(NEXTTOPLEVEL,base,ruleID);

}

if (updateDisplay) RestoreDisplay(frame->display,locals);

ChangeDepth(-1,frame->label); // plan

if (backtrackPoint == ruleMark) FlushMark(); // discard rule undo

if (trace & (TRACE_MATCH|TRACE_PATTERN) && CheckTopicTrace())

{

char* xname = GetTopicName(currentTopicID);

if (*xname == '^') Log(STDTRACETABLOG,(char*)"Result: %s Plan: %s \r\n",ResultCode(result),name);

else Log(STDTRACETABLOG,(char*)"Result: %s Topic: %s \r\n",ResultCode(result),xname);

}

if (pushed) PopTopic();

if (result & ENDTOPIC_BIT)

{

FlushMark(); // drop our access to this space, we are as done as we can get on this rule

break; // we SUCCEEDED, the plan is done

}

// flush any deeper stack back to spot we started

if (result & FAILCODES) topicIndex = tindex;

// or remove topics we matched on so we become the new master path

RestoreMark(); // undo failed plan

sprintf(end,(char*)"%d",++n);

plan = FindWord(name);

result = (!plan) ? FAILRULE_BIT : NOPROBLEM_BIT;

if (!result && trace & (TRACE_MATCH|TRACE_PATTERN) && CheckTopicTrace()) Log(STDTRACETABLOG,(char*)"NextPlan %s\r\n",name);

}

if (globalDepth != holdd) ReportBug((char*)"PlanCode didn't balance");

ChangeDepth(-1,originalPlan->word); // plancode

if (*currentPlanBuffer == ' ') *currentPlanBuffer = 0; // remove trailing space

// revert to callers environment

planning = oldplan;

currentPlanBuffer = oldCurrentPlanBuffer;

withinLoop = oldWithinLoop;

backtrackable = oldbacktrackable;

stringPlanBase = oldStringPlanBase;

backtrackPoint = oldbacktrackPoint;

result = (FunctionResult)(result & (-1 ^ (ENDTOPIC_BIT|ENDRULE_BIT)));

return result; // these are swallowed

}

static char* SystemCall(char* buffer,char* ptr, CALLFRAME* frame,FunctionResult &result,bool & streamArg)

{

WORDP D = frame->name;

unsigned int j = 0;

char* paren = ptr;

ptr = SkipWhitespace(ptr+1); // aim to next major thing after (

SystemFunctionInfo* info = &systemFunctionSet[D->x.codeIndex];

char* start = ptr;

int flags = 0x00000100; // do we leave this unevaled?

while (ptr && *ptr != ')' && *ptr != ENDUNIT) // read arguments

{

if (info->argumentCount != STREAM_ARG) // break them up

{

if (info->argumentCount == UNEVALED) ptr = ReadCompiledWordOrCall(ptr,buffer);

// unevaled counted arg

else if (info->argumentCount != VARIABLE_ARG_COUNT && info->argumentCount & (flags << j))

ptr = ReadCompiledWord(ptr,buffer);

else // VARIABLE ARG OR COUNTED ARG

{

ptr = GetCommandArg(ptr,buffer,result,OUTPUT_UNTOUCHEDSTRING);

}

callArgumentList[callArgumentIndex] = AllocateStack(buffer);

ptr = SkipWhitespace(ptr);

if (callArgumentList[callArgumentIndex] && callArgumentList[callArgumentIndex][0] == USERVAR_PREFIX &&

strstr(callArgumentList[callArgumentIndex],"$_")) // NOT by reference but by value somewhere in the chain

{

callArgumentList[callArgumentIndex] = AllocateStack(GetUserVariable(callArgumentList[callArgumentIndex])); // pass by unmarked value - no one will try to store thru it

}

++j;

if (result != NOPROBLEM_BIT) return ptr; // arg failed

}

else // swallow unevaled arg stream

{

ptr = BalanceParen(paren,false,false); // start after (, point after closing ) if one can, to next token - it may point 2 after ) or it may point 1 after )

while (*--ptr != ')'){;} // back up to closing

size_t len = ptr++ - start; // length of argument bytes not including paren, and end up after paren

while (start[len-1] == ' ') --len; // dont want trailing blanks

callArgumentList[callArgumentIndex] = AllocateStack(start,len);

streamArg = true;

}

if (!callArgumentList[callArgumentIndex])

{

ReportBug("Stack space exhausted %s",D->word);

result = FAILRULE_BIT;

return ptr;

}

if (++callArgumentIndex >= MAX_ARG_LIST)

{

ReportBug("Globally too many arguments %s",D->word);

result = FAILRULE_BIT;

return ptr;

}

if (info->argumentCount == STREAM_ARG) break; // end of arguments

ptr = SkipWhitespace(ptr);

}

frame->arguments = callArgumentIndex - frame->varBaseIndex - 1;

callArgumentList[callArgumentIndex] = (char*) "";

callArgumentList[callArgumentIndex+1] = (char*) ""; // optional arguments excess

callArgumentList[callArgumentIndex+2] = (char*) ""; // optional arguments excess

callArgumentList[callArgumentIndex+3] = (char*) "";

callArgumentList[callArgumentIndex+4] = (char*) ""; // optional arguments excess

callArgumentList[callArgumentIndex+5] = (char*) ""; // optional arguments excess

if ((trace & (TRACE_OUTPUT|TRACE_USERFN) || D->internalBits & MACRO_TRACE) && !(D->internalBits & NOTRACE_FN) && CheckTopicTrace())

{

--globalDepth; // patch depth because call data should be outside of depth

Log(STDTRACETABLOG,(char*) "System call %s(",D->word);

for (unsigned int i = frame->varBaseIndex + 1; i < callArgumentIndex; ++i)

{

char c = callArgumentList[i][120];

callArgumentList[i][120] = 0;

Log(STDTRACELOG, (char*) "`%s`",callArgumentList[i]);

if (i < (callArgumentIndex - 1)) Log(STDTRACELOG, (char*)",");

callArgumentList[i][120] = c;

}

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

++globalDepth;

}

*buffer = 0; // remove any leftover argument data

fnOutput = start; // for text debugger

if (result & ENDCODES); // failed during argument processing

else

{

char* paren = strchr(frame->label,'(');

*paren = '{';

paren[1] = '}';

ChangeDepth(0,NULL); // enable debugger access now

result = (*info->fn)(buffer);

}

return ptr;

}

char* GetArgOfMacro(int i,char* buffer,int limit)

{

char* x = callArgumentList[i];

if (*x == USERVAR_PREFIX)

{

strncpy(buffer, GetUserVariable(x, false, true), limit);

x = buffer;

}

else if (*x == '_' && IsDigit(x[1]))

{

int id = GetWildcardID(x);

if (id >= 0)

{

strncpy(buffer, wildcardOriginalText[id], limit);

x = buffer;

}

}

else if (*x == '\'' && x[1] == '_' && IsDigit(x[2]))

{

int id = GetWildcardID(x + 1);

if (id >= 0)

{

strncpy(buffer, wildcardCanonicalText[id], limit);

x = buffer;

}

}

else if (*x == LCLVARDATA_PREFIX) x += 2; // skip ``

return x;

}

static void BindVariables(CALLFRAME* frame,FunctionResult& result, char* buffer)

}

static char* InvokeUser(char* &buffer,char* ptr, FunctionResult& result,CALLFRAME* frame,

unsigned int &args,char* &startRawArg)

{

WORDP D = frame->name;

// now do defaulted null arguments

while (frame->definition && (callArgumentIndex - (frame->varBaseIndex+1)) < args) // fill in defaulted args to null

{

callArgumentList[callArgumentIndex++] = AllocateStack("",0);

}

// handle any display variables -- MUST BE DONE AFTER computing arguments and before saving them onto vars

if ((D->internalBits & FUNCTION_BITS) != IS_PLAN_MACRO && frame->definition && frame->definition[0] == '(')

{

frame->display = (char**)stackFree;

frame->code = InitDisplay((char*)frame->definition); // will return 0 if runs out of heap space

if (!frame->code) result = FAILRULE_BIT;

}

// now if args are local vars instead of ^, set them up (we have protected them by now)

if (D->internalBits & MACRO_TRACE && !(D->internalBits & NOTRACE_FN)) trace = (unsigned int) D->inferMark;

BindVariables(frame,result,buffer);

if ((trace & (TRACE_OUTPUT|TRACE_USERFN) || D->internalBits & MACRO_TRACE) && !(D->internalBits & NOTRACE_FN) && CheckTopicTrace())

{

--globalDepth; // patch depth because call data should be outside of depth

char a = *ptr;

*ptr = 0;

Log(STDTRACETABLOG,(char*) "User call %s(%s):(",D->word,startRawArg);

for (unsigned int i = frame->varBaseIndex+1; i < callArgumentIndex; ++i)

{

char* x = GetArgOfMacro(i, buffer,40);

int xlen = strlen(x);

// limited to 40, provide ... and restore

char d[4];

if (xlen > 40) {

d[0] = x[40];

d[1] = x[41];

d[2] = x[42];

d[3] = x[43];

strcpy(x + 40, "...");

}

Log(STDTRACELOG, (char*) "`%s`",x);

if (xlen > 40) {

x[40] = d[0];

x[41] = d[1];

x[42] = d[2];

x[43] = d[3];

}

if (i < (callArgumentIndex - 1)) Log(STDTRACELOG, (char*)", ");

}

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

Log(STDTRACETABLOG,(char*)"");

*ptr = a;

++globalDepth;

}

*buffer = 0; // remove any leftover argument data

// run the definition

if (D->internalBits & NOTRACE_FN) trace = 0;

char* paren = strchr(frame->label,'(');

*paren = '{';

paren[1] = '}';

if (result & ENDCODES)

{

ChangeDepth(0, NULL);

}

else if (callArgumentIndex >= (MAX_ARGUMENT_COUNT-1)) // pinned max (though we could legally arrive by accident on this last one)

{

ChangeDepth(0,NULL);

ReportBug((char*)"User function nesting too deep %d",MAX_ARGUMENT_COUNT);

result = FAILRULE_BIT;

}

else if (frame->definition && (D->internalBits & FUNCTION_BITS) == IS_PLAN_MACRO)

{

frame->arguments = D->w.planArgCount;

ChangeDepth(0,NULL);

result = PlanCode(D,buffer); // run a plan

}

#ifndef DISCARDJAVASCRIPT

else if (frame->code && *frame->code == '*' && !strncmp((char*)frame->code,"*JavaScript",11))

{

ChangeDepth(0,NULL);

result = RunJavaScript((char*)frame->code+11,buffer,args); // point at space after label

}

#endif

else if (frame->definition)

{

ChangeDepth(0,NULL,false);

unsigned int flags = OUTPUT_FNDEFINITION;

if (!(D->internalBits & IS_OUTPUT_MACRO)) flags |= OUTPUT_NOTREALBUFFER;// if we are outputmacro, we are merely extending an existing buffer

Output((char*)frame->code,buffer,result,flags);

}

fnOutput = buffer; // for text debugger

// undo any display variables

if (frame->display) RestoreDisplay(frame->display, frame->definition);

if (callIndex) --callIndex; // safe decrement

if (result & ENDCALL_BIT) result = (FunctionResult) (result ^ ENDCALL_BIT); // terminated user call

return ptr;

}

CALLFRAME* GetCallFrame(int depth)

{

if (depth <= 0) return NULL;

if (depth > globalDepth) return NULL;

return releaseStackDepth[depth];

}

static char* UserCall(char* buffer,char* ptr, CALLFRAME* frame,FunctionResult &result)

{

WORDP D = frame->name;

unsigned int j = 0;

ptr = SkipWhitespace(ptr+1); // aim to next major thing after (

callArgumentBases[callIndex] = callArgumentBase; // call stack

callStack[callIndex++] = D;

unsigned int argflags = 0;

unsigned int args = 0;

if ((D->internalBits & FUNCTION_BITS) == IS_PLAN_MACRO)

{

args = D->w.planArgCount;

}

else if (!D->w.fndefinition)

{

ReportBug((char*)"Missing function definition for %s\r\n",D->word);

result = FAILRULE_BIT;

}

else

{

frame->definition = (char*)FindAppropriateDefinition(D, result);

if (frame->definition)

{

int flags;

frame->definition = ReadInt((char*)frame->definition, flags);

argflags = flags;

unsigned char c = (unsigned char) *frame->definition++;

args = (c >= 'a') ? (c - 'a' + 15) : (c - 'A'); // expected args, leaving us at ( args ...

}

else result = FAILRULE_BIT;

}

frame->arguments = args;

// now process arguments

char* startRawArg = ptr;

char* definition = frame->definition;

while (definition && ptr && *ptr && *ptr != ')') // ptr is after opening (and before an arg but may have white space

{

if (currentRule == NULL) // this is a table function- DONT EVAL ITS ARGUMENTS AND... keep quoted item intact

{

ptr = ReadCompiledWord(ptr,buffer); // return dq args as is

#ifndef DISCARDSCRIPTCOMPILER

if (compiling && ptr == NULL) BADSCRIPT((char*)"TABLE-11 Arguments to %s ran out",D->word)

#endif

}

else

{

bool stripQuotes = (argflags & ( 1 << j)) ? 1 : 0; // want to use quotes

// arguments to user functions are not evaluated, they will be used, in place, in the function.

// EXCEPT evaluation of ^arguments must be immediate to maintain current context- both ^arg and ^"xxx" stuff

ptr = ReadArgument(ptr,buffer,result); // ptr returns on next significant char

if (*buffer == '"' && stripQuotes)

{

size_t len = strlen(buffer);

if (buffer[len-1] == '"')

{

buffer[len-1] = 0;

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

}

// and purify internal \" to simple quote

char* x = buffer;

while ((x = strchr(x,'\\')))

{

if (x[1] == '"') memmove(x,x+1,strlen(x)); // remove

}

}

}

if (*buffer == 0) strcpy(buffer,(char*)"null");// no argument found - caller had null data in argument

// within a function, seeing function argument as an argument

// switch to incoming arg now, later callArgumentBase will be wrong

if (*buffer == '^' && IsDigit(buffer[1]) ) strcpy(buffer,FNVAR(buffer+1) );

if (*buffer == '"' && buffer[1] == ENDUNIT) // internal special quoted item, remove markers.

{

size_t len = strlen(buffer);

if (buffer[len-2] == ENDUNIT)

{

buffer[len-2] = 0;

memmove(buffer,buffer+2,len-1);

}

}

if (*buffer == FUNCTIONSTRING && (buffer[1] == '"' || buffer[1] == '\''))

{

char* buf = AllocateStack(NULL,MAX_BUFFER_SIZE,false); // initial form expected small

size_t len = strlen(buffer);

if (len >= (MAX_BUFFER_SIZE-2)) // overflow our intent

{

ReportBug("FormatString > MAX BUFFER SIZE");

ReleaseStack(buf);

result = FAILRULE_BIT;

return ptr; // ReleaseStack(buf) also happens when ChangeDepth finishes

}

strcpy(buf,buffer);

ReformatString(buf[1],buf+2,buffer,result,0);

ReleaseStack(buf);

}

if (buffer[0] == USERVAR_PREFIX && strstr(buffer,"$_"))

{

char* data = GetUserVariable(buffer)-2;

if (buffer[1] == LOCALVAR_PREFIX && buffer[2] == LOCALVAR_PREFIX) // internal variable from jsonreadcsv

{

callArgumentList[callArgumentIndex++] = data; // shared data ptr

}

else

{

strcpy(buffer,data); // NOT by reference but by marked value

if (!stricmp(buffer,(char*)"null")) *buffer = 0; // pass NOTHING as the value

callArgumentList[callArgumentIndex++] = AllocateStack(buffer);

}

}

else

{

if (!stricmp(buffer,(char*)"null")) *buffer = 0; // pass NOTHING as the value

callArgumentList[callArgumentIndex++] = AllocateStack(buffer);

}

if (!callArgumentList[callArgumentIndex-1])

{

if (callIndex) --callIndex;

result = FAILRULE_BIT;

return ptr;

}

if (callArgumentIndex >= MAX_ARGUMENT_COUNT) --callArgumentIndex; // force lock to fail but swallow all args to update ptr

++j;

ptr = SkipWhitespace(ptr);

} // end of argument processing

// fnvar base remains visible when other frames which are system calls get added

int oldFnvarbase = fnVarbase; // interpret ^0 using this base

fnVarbase = callArgumentBase;

ptr = InvokeUser(buffer,ptr,result,frame,args,startRawArg);

fnVarbase = oldFnvarbase;

return ptr;

}

char* DoFunction(char* name,char* ptr,char* buffer,FunctionResult &result) // DoCall(

{

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

if (!D || !(D->internalBits & FUNCTION_NAME))

{

if (compiling) BADSCRIPT("Attempting to call undefined function %s from table code",name)

result = UNDEFINED_FUNCTION;

return ptr;

}

ptr = SkipWhitespace(ptr);

if (*ptr != '(') // should have been arg list

{

result = FAILRULE_BIT;

return ptr;

}

uint64 start_time = ElapsedMilliseconds();

*buffer = 0;

// restorable context

int oldimpliedIf = impliedIf;

SystemFunctionInfo* info = NULL;

char* oldcode = codeStart;

char* oldRealCode = realCode;

int oldtrace = trace;

if (stricmp(name,"^substitute")) impliedIf = ALREADY_HANDLED; // we all allow immediate if context to pass thru here safely

result = NOPROBLEM_BIT;

if (timerLimit) // check for violating time restriction

{

if (timerCheckInstance == TIMEOUT_INSTANCE)

{

result = FAILINPUT_BIT;

return ptr; // force it to fail all the time

}

if (++timerCheckInstance >= timerCheckRate)

{

timerCheckInstance = 0;

if ((ElapsedMilliseconds() - volleyStartTime) >= timerLimit)

{

result = FAILINPUT_BIT; // time out NOW

timerCheckInstance = TIMEOUT_INSTANCE; // force it to fail all the time

return ptr;

}

}

}

bool systemcall = (D->x.codeIndex && !(D->internalBits & (IS_PLAN_MACRO | IS_TABLE_MACRO))); // system function -- but IS_TABLE_MACRO distinguishes but PLAN also has a topicindex which is a codeindex

char namx[150];

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

CALLFRAME* frame = ChangeDepth(1, namx,false,(systemcall) ? NULL : (ptr+2));

frame->oldbase = callArgumentBase;

frame->name = D;

frame->varBaseIndex = callArgumentIndex - 1; //ARGUMENT(n) base reference

callArgumentBase = frame->varBaseIndex;

bool streamArg = false;

if (systemcall) // system function -- but IS_TABLE_MACRO distinguishes but PLAN also has a topicindex which is a codeindex

{

ptr = SystemCall(buffer,ptr,frame,result,streamArg);

info = &systemFunctionSet[D->x.codeIndex];

}

else // user function (plan macro, inputmacro, outputmacro, tablemacro)) , eg ^call (_10 ^2 it ^call2 (3 ) ) spot each token has 1 space separator

{

ptr = UserCall(buffer,ptr,frame,result);

} // end user function

// things like ^notrace(_$x = 5) should not endanger the variable in outer scope

if ((trace & TRACE_OUTPUT || D->internalBits & MACRO_TRACE || (trace & TRACE_USERFN && frame->definition)) && CheckTopicTrace())

{

// make a short description for which call this is, if we can

char word[MAX_WORD_SIZE];

*word = 0;

if (callArgumentIndex > (frame->varBaseIndex +1))

{

strncpy(word,callArgumentList[frame->varBaseIndex+1],40);

if (*word == '$') strncpy(word,GetUserVariable(word),40);

word[40] = 0;

}

if (trace == TRACE_USERFN) Log(STDTRACETABLOG,(char*)"%s %s(%s) => `%s`",ResultCode(result),name,word,buffer);

else if (info && info->properties & SAMELINE) Log(STDTRACETABLOG,(char*)"%s %s(%s) => `%s`",ResultCode(result),name,word,buffer); // stay on same line to save visual space in log

else Log(STDTRACETABLOG,(char*)"%s %s(%s) => `%s`",ResultCode(result),name,word,buffer);

ReadCompiledWord(buffer,word);

if (!strnicmp(word,"jo-",3) || !strnicmp(word,"ja-",3))

{

int count = 0;

char* limit;

char* buf = InfiniteStack(limit,"DoFunction");

FACT* F = GetSubjectNondeadHead(FindWord(word));

while (F)

{