#include "common.h"

int impliedIf = ALREADY_HANDLED; // testing context of an if

unsigned int withinLoop = 0;

static void TestIf(char* ptr, FunctionResult& result, char* buffer)

}

char* HandleIf(char* ptr, char* buffer, FunctionResult& result)

{

// If looks like this: ^^if ( _0 == null ) 00m{ this is it } 00G else ( 1 ) 00q { this is not it } 004

// a nested if would be ^^if ( _0 == null ) 00m{ ^^if ( _0 == null ) 00m{ this is it } 00G else ( 1 ) 00q { this is not it } 004 } 00G else ( 1 ) 00q { this is not it } 004

// after a test condition is code to jump to next test branch when condition fails

// after { } chosen branch is offset to jump to end of if

bool executed = false;

*buffer = 0;

CALLFRAME* frame = ChangeDepth(1, "If()", false);

frame->code = ptr;

--adjustIndent; // stay showing at prior level

while (ALWAYS) // do test conditions until match

{

char* endptr;

if (*ptr == '(') // old format - std if internals

{

endptr = strchr(ptr, '{') - ACCELLSIZE; // offset to jump past pattern

}

else // new format, can use std if or pattern match

{

endptr = ptr + Decode(ptr);

ptr += ACCELLSIZE; // skip jump to end of pattern and point to pattern

}

// Perform TEST condition

if (!strnicmp(ptr, (char*)"( pattern ", 10)) // pattern if

{

int start = 0;

int end = 0;

wildcardIndex = 0;

int whenmatched = 0;

bool failed = false;

char oldmark[MAX_SENTENCE_LENGTH];

memcpy(oldmark, unmarked, MAX_SENTENCE_LENGTH);

if (trace & (TRACE_PATTERN | TRACE_MATCH | TRACE_SAMPLE) && CheckTopicTrace()) // display the entire matching responder and maybe wildcard bindings

{

Log(USERLOG, " IF Pattern... \r\n");

}

MARKDATA hitdata;

hitdata.start = start;

if (!Match(ptr + 10, 0, hitdata, 1, 0, whenmatched, '(')) failed = true; // skip paren and blank, returns start as the location for retry if appropriate

start = hitdata.start;

end = hitdata.end;

memcpy(unmarked, oldmark, MAX_SENTENCE_LENGTH);

ShowMatchResult((failed) ? FAILRULE_BIT : NOPROBLEM_BIT, ptr + 10, NULL);

// cannot use @retry here

if (!failed)

{

if (trace & (TRACE_PATTERN | TRACE_MATCH | TRACE_SAMPLE) && CheckTopicTrace()) // display the entire matching responder and maybe wildcard bindings

{

Log(USERLOG, "** Match: ");

if (wildcardIndex)

{

Log(USERLOG, " Wildcards: (");

for (int i = 0; i < wildcardIndex; ++i)

{

if (*wildcardOriginalText[i]) Log(USERLOG, "_%d=%s / %s (%d-%d) ", i, wildcardOriginalText[i], wildcardCanonicalText[i], wildcardPosition[i] & 0x0000ffff, wildcardPosition[i] >> 16);

else Log(USERLOG, "_%d=null (%d-%d) ", i, wildcardPosition[i] & 0x0000ffff, wildcardPosition[i] >> 16);

}

}

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

}

}

result = (failed) ? FAILRULE_BIT : NOPROBLEM_BIT;

}

else

{

TestIf(ptr + 2, result, buffer);

*buffer = 0;

}

if (trace & TRACE_OUTPUT && CheckTopicTrace())

{

if (result & ENDCODES) Log(USERLOG, "%s\r\n", "FAIL-if");

else Log(USERLOG, ") ");

}

ptr = endptr; // now after pattern, pointing to the skip data to go past body.

*buffer = 0;

// perform SUCCESS branch and then end if

if (!(result & ENDCODES)) // IF test success - we choose this branch

{

executed = true;

ptr += 5;

++adjustIndent;

ptr = Output(ptr, buffer, result); // skip accelerator-3 and space and { and space - returns on next useful token

--adjustIndent;

ptr += Decode(ptr); // offset to end of if entirely

if (*(ptr - 1) == 0) --ptr;// no space after?

break;

}

else

{

result = NOPROBLEM_BIT; // test result is not the IF result

}

// On fail, move to next test

ptr += Decode(ptr);

if (*(ptr - 1) == 0)

{

--ptr;

break; // the if ended abruptly as a stream like in NOTRACE, and there is no space here

}

if (strncmp(ptr, (char*)"else ", 5)) break; // not an ELSE, the IF is over.

ptr += 5; // skip over ELSE space, aiming at the ( of the next condition condition

}

if (executed && trace & TRACE_OUTPUT && CheckTopicTrace()) Log(USERLOG, "End If\r\n");

ChangeDepth(-1, "If()", true);

++adjustIndent; // return to if level

return ptr;

}

char* HandleLoop(char* ptr, char* buffer, FunctionResult& result, bool json)

{

unsigned int oldIterator = currentIterator;

currentIterator = 0;

ChangeDepth(1, "Loop()", false, ptr + 2);

char word[MAX_WORD_SIZE];

WORDP var1 = NULL;

WORDP var2 = NULL;

int match1 = -1; // json args can be match variables OR $ variables

int match2 = -1;

FACT* F = NULL;

result = NOPROBLEM_BIT;

char* paren = strchr(ptr, ')') + 2;

char* endofloop = paren + (size_t)Decode(paren);

int limit = 0;

bool newest = false; // oldest members first

int indexsize = 0;

FACT** stack = NULL;

if (!json)

{

limit = atoi(GetUserVariable((char*)"$cs_looplimit", false));

if (limit == 0) limit = 1000;

char* given = SkipWhitespace(ptr + 1);

if (IsDigit(*given)) limit = atoi(given); // user explicit legal

ptr = GetCommandArg(ptr + 2, buffer, result, 0) + 2; // get the loop counter value and skip closing ) space

}

else

{

limit = 1000000;

char data[MAX_WORD_SIZE];

*data = 0;

ptr = GetCommandArg(ptr + 2, data, result, 0); // get the json object

if (trace & TRACE_OUTPUT && CheckTopicTrace())

{

--adjustIndent;

Log(USERLOG, "jsonloop(%s)\r\n", data);

++adjustIndent;

}

if (!*data)

{

result = NOPROBLEM_BIT;

ChangeDepth(-1, "Loop()", true);

return endofloop; // null value

}

// must be JSON

if (!IsValidJSONName((char*)data))

{

result = FAILRULE_BIT;

ChangeDepth(-1, "Loop()", true);

return endofloop; // we dont know it

}

WORDP jsonstruct = FindWord(data);

if (!jsonstruct) // no known object

{

result = FAILRULE_BIT;

ChangeDepth(-1, "Loop()", true);

return endofloop; // we dont know it

}

F = GetSubjectNondeadHead(jsonstruct);

if (!F)// no members

{

result = NOPROBLEM_BIT;

ChangeDepth(-1, "Loop()", true);

return endofloop; // we dont know it

}

// move onto stack so we can walk either way the elements

char* limited;

stack = (FACT**)InfiniteStack(limited, "handleloop");

while (F) // stack object key data

{

stack[indexsize++] = F;

F = GetSubjectNondeadNext(F);

}

CompleteBindStack64(indexsize, (char*)stack);

// dont bother to release it at end. cutback will handle it

ptr = ReadCompiledWord(ptr, word); // 1st variable

if (*word == '$')

{

if (word[1] != '_')

{

result = FAILRULE_BIT;

ChangeDepth(-1, "Loop()", true);

return endofloop; // we dont know it

}

var1 = StoreWord(word, AS_IS);

}

else match1 = atoi(word + 1);

ptr = ReadCompiledWord(ptr, word); // 2nd variable

if (*word == '$')

{

if (word[1] != '_')

{

result = FAILRULE_BIT;

ChangeDepth(-1, "Loop()", true);

return endofloop; // we dont know it

}

var2 = StoreWord(word, AS_IS);

}

else match2 = atoi(word + 1);

char* at = ReadCompiledWord(ptr, word); // possible ordering modifier

if (*word != ')')

{

if (!stricmp(word, "old")) newest = false;

ptr = at;

}

ptr += 2; // past paren closer

} // end json zone

int counter;

if (*buffer == '@')

{

int set = GetSetID(buffer);

if (set < 0)

{

result = FAILRULE_BIT; // illegal id

ChangeDepth(-1, "Loop()", true);

return ptr;

}

counter = FACTSET_COUNT(set);

}

else if (json) counter = 1000000;

else

{

counter = atoi(buffer);

}

*buffer = 0;

if (result & ENDCODES)

{

ChangeDepth(-1, "Loop()", true);

return endofloop;

}

ptr += 5; // skip jump + space + { + space

++withinLoop; // used by planner

bool infinite = false;

if (counter > limit || counter < 0)

{

counter = limit; // LIMITED

infinite = true; // loop is bounded by defaults

}

--adjustIndent;

int forward = 0;

while (counter-- > 0)

{

if (trace & TRACE_OUTPUT && CheckTopicTrace()) Log(USERLOG, "loop(%d)\r\n", counter + 1);

if (json)

{

if (forward == indexsize || indexsize == 0) break; // end of members

F = (newest) ? stack[forward++] : stack[--indexsize];

char* arg1 = Meaning2Word(F->verb)->word;

if (var1)

{

var1->w.userValue = arg1;

if (trace & TRACE_OUTPUT && CheckTopicTrace()) Log(USERLOG, "var1: %s=>%s ", var1->word, arg1);

}

else // match variable, not $ var

{

strcpy(wildcardOriginalText[match1], arg1); // spot wild cards can be stored

strcpy(wildcardCanonicalText[match1], arg1); // spot wild cards can be stored

if (trace & TRACE_OUTPUT && CheckTopicTrace()) Log(USERLOG, "var1: _%d=>%s ", match1, wildcardOriginalText[match1]);

}

char* arg2 = Meaning2Word(F->object)->word;

if (var2)

{

var2->w.userValue = arg2;

if (trace & TRACE_OUTPUT && CheckTopicTrace()) Log(USERLOG, " var2: %s=>%s\r\n", var2->word, arg2);

}

else

{

strcpy(wildcardOriginalText[match2], arg2); // spot wild cards can be stored

strcpy(wildcardCanonicalText[match2], arg2); // spot wild cards can be stored

if (trace & TRACE_OUTPUT && CheckTopicTrace()) Log(USERLOG, " var2: _%d=>%s\r\n", match2, wildcardOriginalText[match2]);

}

}

FunctionResult result1;

Output(ptr, buffer, result1, OUTPUT_LOOP);

buffer += strlen(buffer);

if (result1 & ENDCODES || result1 & RETRYCODES)

{

if (result1 == NEXTLOOP_BIT) continue;

result = result1;

if (result1 == FAILLOOP_BIT) result = FAILRULE_BIT; // propagate failure outside of loop

else if (result1 == ENDLOOP_BIT) result = NOPROBLEM_BIT; // propagate ok outside of loop

else if (result1 & (ENDRULE_BIT | FAILRULE_BIT)) result = NOPROBLEM_BIT;

// rule level terminates only the loop

break;// potential failure if didnt add anything to buffer

}

}

ChangeDepth(-1, "Loop{}", true); // allows step out to cover a loop

++adjustIndent;

if (trace & TRACE_OUTPUT && CheckTopicTrace()) Log(USERLOG, "end of loop\r\n");

if (counter < 0 && infinite)

ReportBug("INFO: Loop ran to limit %d\r\n", limit);

--withinLoop;

currentIterator = oldIterator;

return endofloop;

}

FunctionResult MemberRelation(WORDP set, char* val1)

}

FunctionResult HandleRelation(char* word1, char* op, char* word2, bool output, int& id, char* word1val, char* word2val)

}