#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 4

char* currentFunctionDisplay;

char* fnOutput = NULL;

char lognames[MAX_LOG_NAMES][200];

FILE* logfiles[4];

char* codeStart = NULL;

char* realCode = NULL;

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

char* currentFunctionName = "";

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

unsigned int callArgumentBases[MAX_CALL_DEPTH]; // arguments to functions

WORDP callStack[MAX_CALL_DEPTH];

unsigned int callIndex = 0;

unsigned int callArgumentIndex;

unsigned int callArgumentBase;

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

}

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 && !AllocateStackSlot(word)) return 0; // leaves display hanging badly BUG

}

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 = callArgumentList[atoi(word+1)+fnVarBase];

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;

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;

SAVEOLDCONTEXT()

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;

ChangeDepth(1,GetTopicName(currentTopicID)); // plancode

unsigned int oldTopicDisplay = currentTopicDisplay;

currentTopicDisplay = currentTopicID;

char* locals = GetTopicLocals(currentTopicID);

if (locals && currentTopicDisplay != oldTopicDisplay && !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 (locals && currentTopicDisplay != oldTopicDisplay) RestoreDisplay(releaseStackDepth[globalDepth],locals);

currentTopicDisplay = oldTopicDisplay;

ChangeDepth(-1,GetTopicName(currentTopicDisplay)); // 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);

}

RESTOREOLDCONTEXT()

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, WORDP D,FunctionResult &result,bool & streamArg,unsigned int firstArgument)

{

unsigned int j = 0;

char* paren = ptr;

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

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

callArgumentBase = callArgumentIndex - 1;

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

}

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

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

else

{

ChangeDepth(1,D->word);

if (streamArg) ChangeDepth(1,""); // argument processing by streamer is invisible to step

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

if (streamArg) ChangeDepth(-1,"",true);

ChangeDepth(-1,D->word,streamArg);

}

return ptr;

}

char* InvokeUser(char* &buffer,char* ptr, FunctionResult& result,WORDP D,unsigned char* &definition,unsigned int &oldArgumentIndex,

unsigned int &args,unsigned int &firstArgument,char* &startRawArg)

{

// handle any display variables

char* basevalues = 0;

char* oldFunctionDisplay = currentFunctionDisplay;

currentFunctionDisplay = 0;

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

{

currentFunctionDisplay = (char*)(definition);

basevalues = stackFree; // here is where we allocate values

definition = (unsigned char*) InitDisplay((char*)definition); // will return 0 if runs out of heap space

if (!definition) result = FAILRULE_BIT;

}

// now do defaulted null arguments

while (definition && (callArgumentIndex - oldArgumentIndex) < args) // fill in defaulted args to null

{

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

}

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

char var[MAX_WORD_SIZE];

char* list = (currentFunctionDisplay) ? (currentFunctionDisplay + 2) : NULL; // skip ( and space xxxx

if (list) for (unsigned int i = oldArgumentIndex; i < callArgumentIndex; ++i)

{

list = ReadCompiledWord(list,var);

if (*var == USERVAR_PREFIX)

{

WORDP arg = FindWord(var);

if (!arg) continue; // should never happen

char* val = callArgumentList[i]; // constants wont have `` in front of them

if (*val == USERVAR_PREFIX) val = GetUserVariable(val);

else if (*val == SYSVAR_PREFIX)

{

Output(val,buffer,result,0);

val = AllocateStack(buffer,0,true);

*buffer = 0;

}

else if (val[0] == ENDUNIT && val[1] == ENDUNIT) val += 2; // skip over noeval marker

else if (val[0] == '\'' && val[1] == '_' && IsDigit(val[2]))

{

int id = GetWildcardID(val+1);

if (id >= 0) val = AllocateStack(wildcardOriginalText[id],0,true);

else val = AllocateStack("");

}

else if (val[0] == '_' && IsDigit(val[1]))

{

int id = GetWildcardID(val);

if (id >= 0) val = AllocateStack(wildcardCanonicalText[id],0,true);

else val = AllocateStack("");

}

else if (*val && *(val-1) != '`') val = AllocateStack(val,0,true);

arg->w.userValue = val;

}

}

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

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 = firstArgument; i < callArgumentIndex; ++i)

{

char* x = callArgumentList[i];

if (*x == USERVAR_PREFIX)

{

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

x = buffer;

}

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

{

int id = GetWildcardID(x);

if (id >= 0)

{

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

x = buffer;

}

}

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

{

int id = GetWildcardID(x+1);

if (id >= 0)

{

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

x = buffer;

}

}

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

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

char d[4];

d[0] = x[40];

d[1] = x[41];

d[2] = x[42];

d[3] = x[43];

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

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

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;

}

fnVarBase = callArgumentBase = oldArgumentIndex;

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

// run the definition

codeStart = NULL;

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

if (result & ENDCODES) ChangeDepth(1,D->word);

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

{

ChangeDepth(1,D->word);

// undo any display variables

if (definition && currentFunctionDisplay) RestoreDisplay(basevalues,currentFunctionDisplay);

currentFunctionDisplay = oldFunctionDisplay;

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

result = FAILRULE_BIT;

}

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

{

ChangeDepth(1,D->word);

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

}

#ifndef DISCARDJAVASCRIPT

else if (definition && *definition == '*' && !strncmp((char*)definition,"*JavaScript",11))

{

ChangeDepth(1,D->word);

result = RunJavaScript((char*)definition+11,buffer,args); // point at space after label

}

#endif

else if (definition)

}

fnOutput = buffer;

ChangeDepth(-1,D->word,false,NULL,result);

// undo any display variables

if (definition && currentFunctionDisplay) RestoreDisplay(basevalues,currentFunctionDisplay);

currentFunctionDisplay = oldFunctionDisplay;

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

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

return ptr;

}

char* UserCall(char* buffer,char* ptr, WORDP D,FunctionResult &result,unsigned int firstArgument,

unsigned char* &definition,unsigned int oldArgumentBase,unsigned int oldArgumentIndex)

{

unsigned int j = 0;

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

callArgumentBases[callIndex] = callArgumentIndex - 1; // call stack

callStack[callIndex++] = D;

unsigned int argflags = 0;

unsigned int args = 0;

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

{

definition = NULL;

args = D->w.planArgCount;

}

else if (!D->w.fndefinition)

{

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

result = FAILRULE_BIT;

}

else

{

definition = FindAppropriateDefinition(D, result);

if (definition)

{

int flags;

definition = (unsigned char*) ReadInt((char*)definition, flags);

argflags = flags;

args = *definition++ - 'A'; // expected args, leaving us at ( args ...

}

else result = FAILRULE_BIT;

}

// now process arguments

char* startRawArg = ptr;

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,callArgumentList[atoi(buffer+1) + fnVarBase]);

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

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); // yevs pattern doesnt space right

} // end of argument processing

ptr = InvokeUser(buffer,ptr,result,D,definition,oldArgumentIndex,args,firstArgument,startRawArg);

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;

}

clock_t start_time = ElapsedMilliseconds();

*buffer = 0;

// restorable context

char* oldcurrent = currentFunctionName;

int oldimpliedIf = impliedIf;

SystemFunctionInfo* info = NULL;

char* oldcode = codeStart;

char* oldRealCode = realCode;

unsigned int oldArgumentBase = callArgumentBase;

unsigned int oldArgumentIndex = callArgumentIndex;

unsigned int oldFnVarBase = fnVarBase;

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;

}

}

}

ChangeDepth(1,"");

currentFunctionName = D->word;

bool streamArg = false;

unsigned char* definition = NULL;

unsigned int firstArgument = callArgumentIndex;

if (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

{

ptr = SystemCall(buffer,ptr,D,result,streamArg,firstArgument);

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,D,result,firstArgument,definition,oldArgumentBase,oldArgumentIndex);

} // end user function

fnVarBase = oldFnVarBase;

ChangeDepth(-1,"",streamArg); // dont cut back ReleaseStacks of a stream

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

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

{

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

char word[MAX_WORD_SIZE];

*word = 0;

if (callArgumentIndex > firstArgument)

{

strncpy(word,callArgumentList[firstArgument],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)

{

if (++count <= 2) Log(STDTRACELOG,(char*)" e.g. %s,", WriteFact(F,false,buf,true,false));

else break;

F = GetSubjectNondeadNext(F);

}

ReleaseInfiniteStack();

Log(STDTRACELOG,(char*)" - size %d facts", count);

}

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

}

// currently only user functions- NOTRACE printouts would be boring

if (definition && (timing & TIME_USERFN || D->internalBits & MACRO_TIME) && !(D->internalBits & NOTIME_FN) && CheckTopicTime()) {

int diff = ElapsedMilliseconds() - start_time;

if (diff > 0 || timing & TIME_ALWAYS )

{

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

char word[MAX_WORD_SIZE];

*word = 0;

if (callArgumentIndex > firstArgument)

{

strncpy(word,callArgumentList[firstArgument],40);

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

word[40] = 0;

}

Log(STDTIMETABLOG, (char*)"%s(%s) time: %d ms\r\n", name,word,diff);

}

}

// pop argument list

callArgumentIndex = oldArgumentIndex;

callArgumentBase = oldArgumentBase;

currentFunctionName = oldcurrent;

codeStart = oldcode;

impliedIf = oldimpliedIf;

realCode = oldRealCode;

trace = (modifiedTrace) ? modifiedTraceVal : oldtrace;

if (ptr && *ptr == ')') // skip ) and space if there is one...

{

if (ptr[1] == ' ') return ptr+2; // if this is a pattern comparison, this will NOT be a space, but will be a comparison op instead missing it

return ptr+1; // ptr to the end unit

}

else return ptr;