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

{ // word is a stream terminated by )

// if (%rand == 5 ) example of a comparison

// if (@14) {} nonempty factset

// if (^QuerySubject()) example of a call or if (!QuerySubject())

// if ($var) example of existence

// if ('_3 == 5) quoted matchvar

// if (1) what an else does

char* word1 = AllocateStack(NULL, maxBufferSize); // not expecting big value in test condition.

char op[MAX_WORD_SIZE];

int id;

impliedIf = 1;

bool header = false;

resume:

ptr = ReadCompiledWord(ptr, word1); // the var or whatever

bool invert = false;

if (*word1 == '!') // inverting, go get the actual

{

invert = true;

// get the real token

if (word1[1]) memmove(word1, word1 + 1, strlen(word1));

else ptr = ReadCompiledWord(ptr, word1);

}

ptr = ReadCompiledWord(ptr, op); // the test if any, or (for call or ) for closure or AND or OR

bool call = false;

if (trace & TRACE_OUTPUT && !header && CheckTopicTrace() && *word1 == '1' && word1[1] == 0)

id = Log(USERLOG, "else( ");

else if (trace & TRACE_OUTPUT && !header && CheckTopicTrace()) id = Log(USERLOG, "if (");

header = true;

if (*op == '(') // function call instead of a variable. but the function call might output a value which if not used, must be considered for failure

{

call = true;

ptr -= strlen(word1) + 3; // back up so output can see the fn name and space

ptr = Output(ptr, buffer, result, OUTPUT_ONCE | OUTPUT_KEEPSET); // buffer hold output value // skip past closing paren

if (result & SUCCESSCODES) result = NOPROBLEM_BIT; // legal way to terminate the piece with success at any level

if (trace & TRACE_OUTPUT && CheckTopicTrace())

{

if (*word1 == '^') { ; } // it will have declared itself, no need to trace here

else if (result & ENDCODES) id = Log(USERLOG, "%c%s ", (invert) ? '!' : ' ', word1);

else if (*word1 == '1' && word1[1] == 0) id = Log(USERLOG, "else ");

else id = Log(USERLOG, "%c%s ", (invert) ? '!' : ' ', word1);

}

ptr = ReadCompiledWord(ptr, op); // find out what happens next after function call

if (result == NOPROBLEM_BIT && IsComparison(*op)) // didnt fail and followed by a relationship op, move output as though it was the variable

{

strcpy(word1, buffer);

call = false; // proceed normally

}

else if (result != NOPROBLEM_BIT) { ; } // failed

else if (!stricmp(buffer, (char*)"0") || !stricmp(buffer, (char*)"false")) result = FAILRULE_BIT; // treat 0 and false as failure along with actual failures

}

*buffer = 0;

if (call) { ; } // call happened

else if (IsComparison(*op)) // a comparison test

{

char word1val[MAX_WORD_SIZE];

char word2val[MAX_WORD_SIZE];

ptr = ReadCompiledWord(ptr, buffer);

realCode = ptr;

result = HandleRelation(word1, op, buffer, true, id, word1val, word2val);

realCode = 0;

ptr = ReadCompiledWord(ptr, op); // AND, OR, or )

}

else // existence of non-failure or any content

{

if (*word1 == SYSVAR_PREFIX || *word1 == '_' || *word1 == USERVAR_PREFIX || *word1 == '@' || *word1 == '?' || *word1 == '^')

{

char* remap = AllocateStack(NULL, maxBufferSize);

strcpy(remap, word1); // for tracing

if (*word1 == INDIRECT_PREFIX && IsDigit(word1[1])) strcpy(word1, FNVAR(word1)); // simple function var, remap it

const char* found;

if (word1[0] == LCLVARDATA_PREFIX && word1[1] == LCLVARDATA_PREFIX)

found = word1 + 2; // preevaled function variable

else if (*word1 == SYSVAR_PREFIX) found = SystemVariable(word1, NULL);

else if (*word1 == '_') found = wildcardCanonicalText[GetWildcardID(word1)];

else if (*word1 == USERVAR_PREFIX) found = GetUserVariable(word1, false);

else if (*word1 == '?') found = (tokenFlags & QUESTIONMARK) ? "1" : "";

else if (*word1 == '^' && word1[1] == USERVAR_PREFIX) // indirect var

{

found = GetUserVariable(word1 + 1, false);

found = GetUserVariable(found, true);

}

else if (*word1 == INDIRECT_PREFIX && word1[1] == '^' && IsDigit(word1[2])) found = ""; // indirect function var

else if (*word1 == '^' && word1[1] == '_') found = ""; // indirect var

else if (*word1 == '^' && word1[1] == '\'' && word1[2] == '_') found = ""; // indirect var

else if (*word1 == '@') found = FACTSET_COUNT(GetSetID(word1)) ? "1" : "";

else found = word1;

if (trace & TRACE_OUTPUT && CheckTopicTrace())

{

char* label = AllocateBuffer();

strcpy(label, word1);

if (*remap == '^') sprintf(label, "%s->%s", remap, word1);

const char* didfind = found;

if (didfind == nullGlobal) didfind = NULL;

else if (didfind == (nullLocal + 2)) didfind = NULL;

if (!didfind) // true null (not empty string)

{

if (invert) id = Log(USERLOG, "!%s`null` ", label);

else id = Log(USERLOG, "%s`null` ", label);

}

else

{

if (invert) id = Log(USERLOG, "!%s`%s` ", label, found);

else id = Log(USERLOG, "%s`%s` ", label, found);

}

FreeBuffer();

}

ReleaseStack(remap);

if (!found || !*found) result = FAILRULE_BIT;

else result = NOPROBLEM_BIT;

}

else // its a constant of some kind

{

if (trace & TRACE_OUTPUT && CheckTopicTrace())

{

if (*word1 == '1' && !word1[1]) {} // dont show the else test

else if (result & ENDCODES) id = Log(USERLOG, "%c%s ", (invert) ? '!' : ' ', word1);

else id = Log(USERLOG, "%c%s ", (invert) ? '!' : ' ', word1);

}

ptr -= strlen(word1) + 3; // back up to process the word and space

ptr = Output(ptr, buffer, result, OUTPUT_ONCE | OUTPUT_KEEPSET) + 2; // returns on the closer and we skip to accel

}

}

if (invert) result = (result & ENDCODES) ? NOPROBLEM_BIT : FAILRULE_BIT;

if (*op == 'a') // AND - compiler validated it

{

if (!(result & ENDCODES))

{

if (trace & TRACE_OUTPUT && CheckTopicTrace()) id = Log(USERLOG, " AND ");

goto resume;

// If he fails (result is one of ENDCODES), we fail

}

else

{

if (trace & TRACE_OUTPUT && CheckTopicTrace()) id = Log(USERLOG, " ... ");

}

}

else if (*op == 'o') // OR

{

if (!(result & ENDCODES))

{

if (trace & TRACE_OUTPUT && CheckTopicTrace()) id = Log(USERLOG, " ... ");

result = NOPROBLEM_BIT;

}

else

{

if (trace & TRACE_OUTPUT && CheckTopicTrace()) id = Log(USERLOG, " OR ");

goto resume;

}

}

ReleaseStack(word1);

*buffer = 0;

impliedIf = ALREADY_HANDLED;

}

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 result = FAILRULE_BIT;

if (!set) return result;

if (strchr(val1, '_')) // try alternate form with no _

{

char* underscore = val1;

bool changed = false;

while ((underscore = strchr(underscore, '_')))

{

*underscore = ' ';

changed = true;

}

if (changed)

{

WORDP D1 = FindWord(val1);

if (D1)

{

NextInferMark();

if (SetContains(MakeMeaning(set), MakeMeaning(D1))) result = NOPROBLEM_BIT;

}

}

}

else if (strchr(val1, ' ')) // try alternate form with no space

{

char* underscore = val1;

bool changed = false;

while ((underscore = strchr(underscore, ' ')))

{

*underscore = '_';

changed = true;

}

if (changed)

{

WORDP D1 = FindWord(val1);

if (D1)

{

NextInferMark();

if (SetContains(MakeMeaning(set), MakeMeaning(D1))) result = NOPROBLEM_BIT;

}

}

}

return result;

}

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

{ // word1 and word2 are RAW, ready to be evaluated.

*word1val = 0;

*word2val = 0;

char* val1 = AllocateStack(NULL, maxBufferSize);

char* val2 = AllocateStack(NULL, maxBufferSize);

WORDP D;

WORDP D1;

WORDP D2;

int64 v1 = 0;

int64 v2 = 0;

FunctionResult result, val1Result;

FreshOutput(word1, val1, result, OUTPUT_ONCE | OUTPUT_KEEPSET | OUTPUT_NOCOMMANUMBER | OUTPUT_NODEBUG); // 1st arg

val1Result = result;

if (trace & TRACE_OUTPUT && output && CheckTopicTrace())

{

char* traceop = op;

if (!traceop) traceop = "x";

char x[MAX_WORD_SIZE];

*x = 0;

if (*op == '&')

{

#ifdef WIN32

sprintf(x, (char*)"0x%016I64x", v1);

#else

sprintf(x, (char*)"0x%016llx", v1);

#endif

}

if (!stricmp(word1, val1))

{

if (*word1) Log(USERLOG, "%s %s ", word1, traceop); // no need to show value

else Log(USERLOG, "null %s ", traceop);

}

else Log(USERLOG, "%s`%s` %s ",word1,val1,op);

}

if (word2 && *word2) FreshOutput(word2, val2, result, OUTPUT_ONCE | OUTPUT_KEEPSET | OUTPUT_NOCOMMANUMBER | OUTPUT_NODEBUG); // 2nd arg

if (word2 && *word2 && trace & TRACE_OUTPUT && output && CheckTopicTrace())

{

char x[MAX_WORD_SIZE];

*x = 0;

if (*op == '&') strcpy(x, PrintX64(v1));

if (word2 && !strcmp(word2, val2))

{

if (*val2) id = Log(USERLOG, " %s ", word2); // no need to show value

else id = Log(USERLOG, " null ");

}

else if (*op == '&') id = Log(USERLOG, " %s`%s` ", word2, x);

else id = Log(USERLOG, " %s`%s` ", word2, val2);

}

result = FAILRULE_BIT;

if (!stricmp(val1, (char*)"null")) *val1 = 0; // JSON null values

if (!stricmp(val2, (char*)"null")) *val2 = 0;

if (!op)

{

if (val1Result & ENDCODES); // explicitly failed

else if (*val1) result = NOPROBLEM_BIT; // has some value

}

else if (*op == '?' || op[1] == '?') // ? and !?

{

if (*word1 == '\'') ++word1; // ignore the quote since we are doing positional

if (*word1 == '_') // use only precomputed match from memorization

{

unsigned int index = GetWildcardID(word1);

unsigned int begin = WILDCARD_START(wildcardPosition[index]);

unsigned int finish = WILDCARD_END_ONLY(wildcardPosition[index]);

D = FindWord(val2); // as is

if (begin && D)

{

MARKDATA hitdata;

if (GetNextSpot(D, begin - 1, false,0,&hitdata) == begin && (unsigned int)(hitdata.end & REMOVE_SUBJECT) == finish) result = NOPROBLEM_BIT; // otherwise failed and we would have known

}

if (*op == '!') result = (result != NOPROBLEM_BIT) ? NOPROBLEM_BIT : FAILRULE_BIT;

}

else if (IsValidJSONName(val2, 'a')) // is it in array?

{

result = FAILRULE_BIT;

D = FindWord(val1);

if (D)

{

MEANING M = MakeMeaning(D);

D = FindWord(val2);

if (D)

{

FACT* F = GetSubjectNondeadHead(D);

while (F)

{

if (F->object == M)

{

result = NOPROBLEM_BIT;

break;

}

F = GetSubjectNondeadNext(F);

}

}

}

}

else if (!stricmp(word2, "~number")) // number

{

if (*word1 == '$') word1 = GetUserVariable(word1);

return IsPureNumber(word1) ? NOPROBLEM_BIT : FAILRULE_BIT;

}

else // laborious.

{

D1 = FindWord(val1);

D2 = FindWord(val2);

if (D1 && D2)

{

NextInferMark();

if (SetContains(MakeMeaning(D2), MakeMeaning(D1))) result = NOPROBLEM_BIT;

}

if (result != NOPROBLEM_BIT) result = MemberRelation(D2, val1);

if (*op == '!') result = (result != NOPROBLEM_BIT) ? NOPROBLEM_BIT : FAILRULE_BIT;

}

}

else // boolean tests

{

// convert null to numeric operator for < or > -- but not for equality

if (!*val1 && (IsSign(*val2) || IsDigit(*val2)) && IsNumber(val2) != NOT_A_NUMBER && (*op == '<' || *op == '>')) strcpy(val1, (char*)"0");

else if (!*val2 && (IsSign(*val1) || IsDigit(*val1)) && IsNumber(val1) != NOT_A_NUMBER && (*op == '<' || *op == '>')) strcpy(val2, (char*)"0");

// treat #123 as string but +21545 and -12345 as numbers

char* currency1;

char* currency2;

unsigned char* cur1 = GetCurrency((unsigned char*)val1, currency1);

unsigned char* cur2 = GetCurrency((unsigned char*)val2, currency2); // use text string comparison though isdigitword calls it a number

char* end1 = val1 + strlen(val1);

char* end2 = val2 + strlen(val2);

if (*val1 == '#' || !IsDigitWord(val1, AMERICAN_NUMBERS, true) || *val2 == '#' || !IsDigitWord(val2, AMERICAN_NUMBERS, true) ||

strchr(val1, ':') || strchr(val2, ':') ||

strchr(val1, '%') || strchr(val2, '%') || cur1 || cur2) // non-numeric string compare - bug, can be confused if digit starts text string

{

char* arg1 = val1;

char* arg2 = val2;

if (*arg1 == '"' && arg1[1]) // truly a string

{

size_t len = strlen(arg1);

if (arg1[len - 1] == '"') // remove STRING markers

{

arg1[len - 1] = 0;

++arg1;

}

}

if (*arg2 == '"' && arg2[1])

{

size_t len = strlen(arg2);

if (arg2[len - 1] == '"') // remove STRING markers

{

arg2[len - 1] = 0;

++arg2;

}

}

if (*op == '!') result = (stricmp(arg1, arg2)) ? NOPROBLEM_BIT : FAILRULE_BIT;

else if (*op == '=')

{

result = (!stricmp(arg1, arg2)) ? NOPROBLEM_BIT : FAILRULE_BIT;

}

else if (*op == '>' && op[1] == '=') result = (stricmp(arg1, arg2) >= 0) ? NOPROBLEM_BIT : FAILRULE_BIT;

else if (*op == '<' && op[1] == '=') result = (stricmp(arg1, arg2) <= 0) ? NOPROBLEM_BIT : FAILRULE_BIT;

else if (*op == '>') result = (stricmp(arg1, arg2) > 0) ? NOPROBLEM_BIT : FAILRULE_BIT;

else if (*op == '<') result = (stricmp(arg1, arg2) < 0) ? NOPROBLEM_BIT : FAILRULE_BIT;

else result = FAILRULE_BIT;

}

// handle double ops

else if (IsFloat(val1, end1) || IsFloat(val2, end2)) // at least one arg is float

{

char* comma = 0;

while ((comma = strchr(val1, ','))) memmove(comma, comma + 1, strlen(comma)); // remove embedded commas

while ((comma = strchr(val2, ','))) memmove(comma, comma + 1, strlen(comma)); // remove embedded commas

double v1f = Convert2Double(val1);

double v2f = Convert2Double(val2);

if (*op == '=') result = (v1f == v2f) ? NOPROBLEM_BIT : FAILRULE_BIT;

else if (*op == '<')

{

if (!op[1]) result = (v1f < v2f) ? NOPROBLEM_BIT : FAILRULE_BIT;

else result = (v1f <= v2f) ? NOPROBLEM_BIT : FAILRULE_BIT;

}

else if (*op == '>')

{

if (!op[1]) result = (v1f > v2f) ? NOPROBLEM_BIT : FAILRULE_BIT;

else result = (v1f >= v2f) ? NOPROBLEM_BIT : FAILRULE_BIT;

}

else if (*op == '!') result = (v1f != v2f) ? NOPROBLEM_BIT : FAILRULE_BIT;

else result = FAILRULE_BIT;

}

else // int compare

{

char* comma = 0; // pretty number?

while ((comma = strchr(val1, ','))) memmove(comma, comma + 1, strlen(comma));

while ((comma = strchr(val2, ','))) memmove(comma, comma + 1, strlen(comma));

ReadInt64(val1, v1);

ReadInt64(val2, v2);

if (strchr(val1, ',') && strchr(val2, ',')) // comma numbers

{

size_t len1 = strlen(val1);

size_t len2 = strlen(val2);

if (len1 != len2) result = FAILRULE_BIT;

else if (strcmp(val1, val2)) result = FAILRULE_BIT;

else result = NOPROBLEM_BIT;

if (*op == '!') result = (result == NOPROBLEM_BIT) ? FAILRULE_BIT : NOPROBLEM_BIT;

else if (*op != '=') ReportBug((char*)"INFO: Op not implemented for comma numbers %s", op);

}

else if (*op == '=') result = (v1 == v2) ? NOPROBLEM_BIT : FAILRULE_BIT;

else if (*op == '<')

{

if (!op[1]) result = (v1 < v2) ? NOPROBLEM_BIT : FAILRULE_BIT;

else result = (v1 <= v2) ? NOPROBLEM_BIT : FAILRULE_BIT;

}

else if (*op == '>')

{

if (!op[1]) result = (v1 > v2) ? NOPROBLEM_BIT : FAILRULE_BIT;

else result = (v1 >= v2) ? NOPROBLEM_BIT : FAILRULE_BIT;

}

else if (*op == '!') result = (v1 != v2) ? NOPROBLEM_BIT : FAILRULE_BIT;

else if (*op == '&') result = (v1 & v2) ? NOPROBLEM_BIT : FAILRULE_BIT;

else result = FAILRULE_BIT;

}

}

ReleaseStack(val1);

return result;

}