#include "common.h"

unsigned int maxOutputUsed = 0;

unsigned int currentOutputLimit = MAX_BUFFER_SIZE; // max size of current output base

char* currentOutputBase = NULL; // current base of buffer which must not overflow

char* outputBase = NULL;

char* currentRuleOutputBase = NULL; // the partial buffer within outputbase started for current rule, whose output can be canceled.

#define MAX_OUTPUT_NEST 50

static char* oldOutputBase[MAX_OUTPUT_NEST];

static char* oldOutput[MAX_OUTPUT_NEST];

static char* oldOutputRuleBase[MAX_OUTPUT_NEST];

static unsigned int oldOutputLimit[MAX_OUTPUT_NEST];

char* outputCode[MAX_GLOBAL];

int oldOutputIndex = 0;

unsigned int outputNest = 0;

static char* ProcessChoice(char* ptr, char* buffer, FunctionResult& result, int controls);

static char* Output_Function(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult& result, bool once);

static char* Output_Dollar(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult& result, bool once, bool nojson);

#ifdef JUNK

Special strings :

When you put ^ "xxxx" as a string in a normal output field, it is a format string.By definition you didnt need it compileable.

It will be treated...

When you use it as an argument to a function(top level), it is compiled.

When you put ^ "xxxx" as a string in a table, it will be compiledand be either a pattern compile or an output compile.

Internally that becomes "^xxx" which is fully executable.

#endif

bool SafeCopy(char* output, char* word, bool space)

}

void ResetOutput()

{

outputNest = 0;

}

void PushOutputBuffers()

}

void PopOutputBuffers()

}

void AllocateOutputBuffer()

}

void FreeOutputBuffer()

}

static bool IsAssignmentOperator(char* word)

}

char* GetCommandArg(char* ptr, char* buffer, FunctionResult& result, unsigned int control)

{

int oldImpliedSet = impliedSet; // so @0object will decode

if (!(control & ASSIGNMENT)) impliedSet = ALREADY_HANDLED;

if (control == 0) control |= OUTPUT_KEEPSET | OUTPUT_ONCE | OUTPUT_NOCOMMANUMBER | OUTPUT_NODEBUG;

else control |= OUTPUT_ONCE | OUTPUT_NOCOMMANUMBER | OUTPUT_NODEBUG;

unsigned int remains = outputsize - (buffer - outputBase); // how much is left in buffer

ptr = FreshOutput(ptr, buffer, result, control, remains);

if (!(control & ASSIGNMENT)) impliedSet = oldImpliedSet; // assignment of @0 = ^querytopics needs to be allowed to change to alreadyhandled

return ptr;

}

char* ReadShortCommandArg(char* ptr, char* buffer, FunctionResult& result, unsigned int control) // always word size or less

{

int oldImpliedSet = impliedSet; // so @0object will decode

if (!(control & ASSIGNMENT)) impliedSet = ALREADY_HANDLED;

if (control == 0) control |= OUTPUT_KEEPSET | OUTPUT_NOTREALBUFFER | OUTPUT_ONCE | OUTPUT_NOCOMMANUMBER;

else control |= OUTPUT_ONCE | OUTPUT_NOCOMMANUMBER | OUTPUT_NOTREALBUFFER;

char* answer = FreshOutput(ptr, buffer, result, control, MAX_WORD_SIZE);

if (!(control & ASSIGNMENT)) impliedSet = oldImpliedSet; // assignment of @0 = ^querytopics needs to be allowed to change to alreadyhandled

return answer;

}

char* ReadFunctionCommandArg(char* ptr, char* buffer, FunctionResult& result, bool optional)

{

char* at = ptr;

// pass over the ' in the parsing because it stops the text from being interpreted as an active string

if (*at == '\'') ++at;

char* answer = ReadShortCommandArg(at, buffer, result, OUTPUT_NOQUOTES);

if (result != NOPROBLEM_BIT) return answer;

if (!stricmp(buffer, (char*)"null") && optional)

{

*buffer = 0;

}

else if (strlen(buffer) > 0)

{

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

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

{

result = FAILRULE_BIT;

}

}

else if (!optional)

{

result = FAILRULE_BIT;

}

return answer;

}

static char* FixFormatOutput(char* output, unsigned int controls) // revises output in place

{

size_t len = strlen(output);

if (*output == '"' && output[len - 1] == '"' && controls & OUTPUT_NOQUOTES) // strip quotes

{

output[--len] = 0; // remove trailing

memmove(output, output + 1, len--);

}

if (controls & OUTPUT_NOUNDERSCORE)

{

char* at = output;

while ((at = strchr(at, '_'))) *at = ' ';

}

return output + len;

}

static char* ReadUserVariable(char* input, char* var)

{

char* at = input++; // skip $ and below either $ or _ if one exists or first legal char

while (LegalVarChar(*++input) || *input == '.' || *input == '[' || *input == ']' || (*input == '$' && (*(input - 1) == '.' || *(input - 1) == '[')))

{

if (*input == '.' || *input == '[' || *input == ']')

{

if (*input == ']')

{

if (input[1] != '[' && input[1] != '.')

{

++input;

break;

}

}

else if (!LegalVarChar(input[1]) && input[1] != '$' && input[1] != '[' && input[1] != '.')

{

if (*input == ']') ++input; // add to var this closing

break; // not a var dot, just an ordinary one

}

}

}

strncpy(var, at, input - at);

var[input - at] = 0;

return input;

}

static char* ReadMatchVariable(char* input, char* var)

{

char* at = input;

while (IsDigit(*++input)) { ; }

strncpy(var, at, input - at);

var[input - at] = 0;

return input;

}

void ReformatString(char starter, char* input, char*& output, FunctionResult& result, unsigned int controls, char* space) // take ^"xxx" format string and perform substitutions on variables within it

}

void StdNumber(char* word, char*& buffer, int controls) // text numbers may have sign and decimal

}

char* StdIntOutput(int n)

{

char buffer[50];

static char answer[50];

*answer = 0;

strcpy(buffer,Print64(n));

char* ptr = answer;

StdNumber(buffer, ptr, 0);

return answer;

}

static char* ProcessChoice(char* ptr, char* buffer, FunctionResult& result, int controls) // given block of [xx] [yy] [zz] randomly pick one

{

char* choice[CHOICE_LIMIT];

char** choiceset = choice;

int count = 0;

char* endptr = 0;

// gather choices

while (*ptr && *ptr == '[') // get next choice for block may not nest choice blocks...

{

// find closing ]

endptr = ptr - 1;

while (ALWAYS)

{

endptr = strchr(endptr + 1, ']'); // find a closing ]

if (!endptr) // failed

{

respondLevel = 0;

return 0;

}

if (*(endptr - 1) != '\\') break; // ignore literal \[

}

// choice can be simple: [ xxx ] or conditional [ $var1 xxx] or conditional [!$var1 xx] but avoid assignment [ $var1 = 10 xxx ]

char word[MAX_WORD_SIZE];

char* base = ptr + 1; // start of 1st token within choice

char* simpleOutput = ReadCompiledWord(base, word);

char* var = word;

bool notted = false;

if (*word == '!')

{

notted = true;

++var;

}

if (*var == USERVAR_PREFIX && (IsAlphaUTF8(var[1]) || var[1] == TRANSIENTVAR_PREFIX || var[1] == LOCALVAR_PREFIX)) // user variable given

{

ReadCompiledWord(simpleOutput, tmpWord);

if (*tmpWord == '=' || tmpWord[1] == '=') choiceset[count++] = base; // some kind of assignment, it's all simple output

else if (!notted && !*GetUserVariable(var)) { ; } // user variable test fails

else if (notted && *GetUserVariable(var)) { ; } // user variable test fails

else choiceset[count++] = simpleOutput;

}

else choiceset[count++] = base;

ptr = SkipWhitespace(endptr + 1); // past end of choice

}

// pick a choice randomly - a choice starts past the [ but has visible the closing ]

respondLevel = 0;

while (count > 0)

{

int r = random(count);

if (outputchoice >= 0 && outputchoice < count) r = outputchoice; // forced by user

char* ptr1 = SkipWhitespace(choiceset[r]);

if (*ptr1 == ']') break; // choice does nothing by intention

char level = 0;

if (IsAlphaUTF8(*ptr1) && ptr1[1] == ':' && IsWhiteSpace(ptr1[2]))

{

level = *ptr1;

ptr1 += 3; // skip special rejoinder

}

Output(ptr1, buffer, result, controls);

if (result & ENDCODES) break; // declared done

// is choice a repeat of something already said... if so try again

if (*buffer && HasAlreadySaid(buffer))

{

if (trace & TRACE_OUTPUT) Log(USERLOG, "Choice %s already said\r\n", buffer);

*buffer = 0;

choiceset[r] = choiceset[--count];

}

else

{

if (level) respondLevel = level;

break; // if choice didnt fail, it has completed, even if it generates no output

}

}

return (endptr[1]) ? (endptr + 2) : (endptr + 1); // skip to end of rand past the ] and space

}

char* FreshOutput(char* ptr, char* buffer, FunctionResult& result, int controls, unsigned int limit)

{ // used to get isolated values not normally part of real output stream

++outputNest;

if (limit != maxBufferSize) AllocateOutputBuffer(); // where he wants to put it is SMALL and we're not ready for that. allocate a big bufer can copy later

else

{

PushOutputBuffers();

currentRuleOutputBase = currentOutputBase = buffer; // is a normal buffer

}

ptr = Output(ptr, currentOutputBase, result, controls); // has no content before it

if (limit != maxBufferSize) // someone's small local buffer

{

size_t olen = strlen(currentRuleOutputBase);

if (olen >= limit)

{

strncpy(buffer, currentRuleOutputBase, limit - 1);

buffer[limit - 1] = 0;

ReportBug((char*)"FreshOutput of %d exceeded caller limit of %d. Truncated: %s\r\n", olen, limit, currentRuleOutputBase);

}

else strcpy(buffer, currentRuleOutputBase);

FreeOutputBuffer();

}

else PopOutputBuffers();

--outputNest;

return ptr;

}

#ifdef INFORMATION

There are two kinds of output streams.The ONCE only stream expects to read an itemand return.

If a fail code is hit when processing an item, then if the stream is ONCE only, it will be done

and return a ptr to the rest.If a general stream hits an error, it has to flush all the remaining

tokensand return a ptr to the end.

#endif

static char* Output_Percent(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result, bool once)

{

// Handles system variables: %date

// Handles any other % item - %

if (IsAlphaUTF8(word[1])) // must be a system variable

{

if (!once && IsAssignmentOperator(ptr)) return PerformAssignment(word, ptr, buffer, result); // = or *= kind of construction

if (!stricmp(word, "%trace_on"))

{

if (!blockapitrace && (!server || VerifyAuthorization(FopenReadOnly((char*)"authorizedIP.txt")))) trace = (unsigned int)-1;

}

else if (!stricmp(word, "%trace_off")) trace = 0;

else strcpy(buffer, SystemVariable(word, NULL));

}

else if (*word) strcpy(buffer, word);

return ptr;

}

static char* Output_Backslash(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result, bool& nospace)

{

// handles newline: \n and equivalent \r

// handles backslashed strings: \"testing" means dump the rest of the token out

// handles backslashed standalone double quote - \" - means treat as even/odd pair and on 2nd one (closing) do not space before it

// handles any other backslashed item: \help means just put out the item without the backslash

if (word[1] == 'n' || word[1] == 'r') // \n

{

if (space) --buffer; // remove space before newline

#ifdef WIN32

strcpy(buffer, (char*)"\\r\\n");

#else

strcpy(buffer, (char*)"\\n");

#endif

ptr -= strlen(word);

if (*ptr == 'n') --ptr;

ptr += 2;

}

else if (word[1] == 't') // tab

{

strcpy(buffer, (char*)"\\t");

ptr -= strlen(word);

if (*ptr == 't') --ptr;

ptr += 2;

}

else strcpy(buffer, word + 1); // some other random backslashed content, including \"

return ptr;

}

static char* ResetOutputPtr(char* start, char* buffer)

{

char* at = strrchr(start, '`'); // where it ended

if (!at) return start;

size_t len = strlen(at + 1);

memmove(start, at + 1, len + 1); // shift new data back to start

if (currentOutputBase != start && start[len - 1] == ' ') --len; // output ended with a space, remove it

else if (len == 1 && start[0] == ' ') len = 0; // output ended with a space, remove it

start[len] = 0;

return start + len; // resume back at original buffer location

}

static char* Output_FunctionVariable(char* word, char* ptr, char*& buffer, FunctionResult & result, bool once)

{

if (!once && IsAssignmentOperator(ptr)) ptr = PerformAssignment(word, ptr, buffer, result);

else if ((word[2] && !IsDigit(word[2])) || (word[2] && word[3]) || atoi(word + 1) >= MAX_ARG_LIMIT) // values start at 1

{

strcpy(buffer, word); // a non function and nonfunction variable

return ptr;

}

else

{

char* value = FNVAR(word );

size_t len = strlen(value);

size_t size = (buffer - currentOutputBase);

if ((size + len) >= (currentOutputLimit - 50))

{

result = FAILRULE_BIT;

return ptr;

}

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

strcpy(buffer, value + 2); // already evaluated. do not reeval

else

{

strcpy(buffer, value);

if (*buffer)

{

*word = ENDUNIT; // marker for retry

word[1] = '^'; // additional marker for function variables

}

}

}

return ptr;

}

static char* Output_User_Match_and_Function_Vars(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result, bool once)

{

if (!once && IsAssignmentOperator(ptr)) // we are lefthand side indirect

{

if (word[1] != '^' || !IsDigit(word[2])) // anything but ^^2

{

Output(word + 1, buffer, result, controls); // no leading space - we now have the variable value from the indirection

strcpy(word, buffer);

}

*buffer = 0;

ptr = PerformAssignment(word, ptr, buffer, result, true); // = or *= kind of construction -- dont do json indirect assignment

}

else // we are right side (expression) indirect

{

if (word[1] == USERVAR_PREFIX && *ptr != '(') // direct retry to avoid json issues (unless function call)

{

strcpy(word, GetUserVariable(word + 1));

*buffer = 0;

Output_Dollar(word, "", space, buffer, controls, result, false, false); // allow json processing

}

else

{

Output(word + 1, buffer, result, controls); // no leading space - we now have the variable value from the indirection

*word = ENDUNIT; // marker for retry

}

}

return ptr;

}

static char* Output_VariableIndirect(char* word, char* ptr, char*& buffer, FunctionResult & result, bool once)

{

if (!once && IsAssignmentOperator(ptr))

ptr = PerformAssignment(word, ptr, buffer, result); // = or *= kind of construction

else if (!word[2]) strcpy(buffer, word); // "^^" exponent operator

else result = FAILRULE_BIT;

return ptr;

}

static char* Output_OrdinaryFunction(char* word, char* ptr, char* space, char*& buffer, FunctionResult & result)

{

char* start = buffer;

if (*currentRuleOutputBase &&

(!strcmp(word, (char*)"^gambit") ||

!strcmp(word, (char*)"^respond") ||

!strcmp(word, (char*)"^reuse") ||

!strcmp(word, (char*)"^retry") ||

!strcmp(word, (char*)"^refine") ||

!strcmp(word, (char*)"^print") ||

!strcmp(word, (char*)"^printbefore") ||

!strcmp(word, (char*)"^printafter") ||

!strcmp(word, (char*)"^sequence"))) // leaving current rule

{

char* end = currentRuleOutputBase;

if (*currentRuleOutputBase == '`') end = strrchr(currentRuleOutputBase, '`') + 1; // is there really something new there?

if (*end && !AddResponse(currentRuleOutputBase, responseControl)) result = FAILRULE_BIT;

if (*start == '`') buffer = ResetOutputPtr(start, buffer);

}

ptr = DoFunction(word, ptr, buffer, result);

if (space && *space != ' ' && result != ENDCALL_BIT) // we need to add a space, but not if requesting a call return ^return

{

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

*buffer = ' ';

}

return ptr;

}

static char* Output_Function(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result, bool once)

{

char* start = buffer;

if (IsDigit(word[1])) ptr = Output_FunctionVariable(word, ptr, buffer, result, once);

else if (word[1] == '"' || word[1] == '\'') ReformatString(word[1], word + 2, buffer, result, 0, space); // functional string, uncompiled. DO NOT USE function calls within it

else if (word[1] == USERVAR_PREFIX || word[1] == '_' || word[1] == '\'' || (word[1] == '^' && IsDigit(word[2]))) // ^$$1 = null or ^_1 = null or ^'_1 = null or ^^which = null is indirect user assignment or retrieval

{

ptr = Output_User_Match_and_Function_Vars(word, ptr, space, buffer, controls, result, once);

}

else if (!strcmp(word, (char*)"^if")) ptr = HandleIf(ptr, buffer, result);

else if (!strcmp(word, (char*)"^loop")) ptr = HandleLoop(ptr, buffer, result, false);

else if (!strcmp(word, (char*)"^jsonloop")) ptr = HandleLoop(ptr, buffer, result, true);

else if (word[1] == '^') ptr = Output_VariableIndirect(word, ptr, buffer, result, once);

else if (*ptr != '(' || !word[1]) strcpy(buffer, word); // a non function

else ptr = Output_OrdinaryFunction(word, ptr, space, buffer, result);

return ptr;

}

static char* Output_AttachedPunctuation(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result)

{

strcpy(buffer, word);

return ptr;

}

static char* Output_Text(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result)

{

// handles text or script

if (*ptr != '(' || controls & OUTPUT_FACTREAD || IsDigit(*word)) StdNumber(word, buffer, controls); // SIMPLE word - paren if any is a nested fact read, or number before ( which cant be ^number

else // function call missing ^?

{

char copy[MAX_WORD_SIZE];

strcpy(copy + 1, word);

*copy = '^'; // supply ^

result = NOPROBLEM_BIT;

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

if (!D || !(D->internalBits & FUNCTION_NAME) || csapicall == TEST_OUTPUT) StdNumber(word, buffer, controls);

else ptr = Output_Function(copy, ptr, space, buffer, controls, result, false);

}

return ptr;

}

static char* Output_AtSign(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result, bool once)

{

// handles factset assignement: @3 = @2

// handles factset field: @3object

if (!once && IsAssignmentOperator(ptr)) ptr = PerformAssignment(word, ptr, buffer, result);

else if (impliedSet != ALREADY_HANDLED) strcpy(buffer, word);

else if (IsDigit(word[1]) && IsAlphaUTF8(*GetSetType(word)) && !(controls & OUTPUT_KEEPQUERYSET)) // fact set reference

{

int store = GetSetID(word);

if (store == ILLEGAL_FACTSET) return ptr;

unsigned int count = FACTSET_COUNT(store);

if (!count || count >= MAX_FIND) return ptr;

FACT* F = factSet[store][1]; // use but don't use up most recent fact

MEANING T;

uint64 flags;

char type = *GetSetType(word);

if (type == 's')

{

T = F->subject;

flags = F->flags & FACTSUBJECT;

}

else if (type == 'v')

{

T = F->verb;

flags = F->flags & FACTVERB;

}

else if (type == 'f')

{

T = Fact2Index(F);

flags = FACTSUBJECT;

}

else if (type == 'a' && impliedWild != ALREADY_HANDLED)

{

CALLFRAME* frame = GetCallFrame(globalDepth);

frame->arguments[1] = AllocateStack(word);

result = FLR(buffer, (char*)"l");

return ptr;

}

else

{

T = F->object;

flags = F->flags & FACTOBJECT;

}

char* answer;

char buf[100];

if (flags)

{

sprintf(buf, (char*)"%u", T);

answer = buf;

}

else answer = Meaning2Word(T)->word;

strcpy(buffer, answer);

}

else strcpy(buffer, word);

return ptr;

}

static char* Output_Bracket(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result)

{

// handles normal token: [ice

// handles choice: [ this is data ]

if (word[1] || (controls & OUTPUT_NOTREALBUFFER && !(controls & OUTPUT_FNDEFINITION)) || !*ptr) StdNumber(word, buffer, controls); // normal token

else

{

while (*ptr != '[') --ptr;

ptr = ProcessChoice(ptr, buffer, result, controls);

}

return ptr;

}

static char* Output_Quote(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result)

{

// handles possessive: 's

// handles original wildcard: '_2

// handles quoted variable: '$hello

if (word[1] == 's' && !word[2]) strcpy(buffer, (char*)"'s"); // possessive

else if (word[1] == '_') // original wildcard

{

int index = GetWildcardID(word + 1); // which one

char* at = wildcardOriginalText[index];

StdNumber(at, buffer, controls);

if (controls & OUTPUT_NOQUOTES && *buffer == '"') // remove quotes from variable data

{

size_t len = strlen(buffer);

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

{

buffer[len - 1] = 0;

memmove(buffer, buffer + 1, len);

}

}

}

else if (word[1] == USERVAR_PREFIX || word[1] == '@' || word[1] == SYSVAR_PREFIX) // variable or factset or system variable quoted, means dont reeval its content

{

strcpy(buffer, word + 1);

}

else if (word[1] == '^' && IsDigit(word[2])) // function variable quoted, means dont reeval its content

{

size_t len = strlen(QUOTEDFNVAR(word ));

size_t size = (buffer - currentOutputBase);

if ((size + len) >= (currentOutputLimit - 50))

{

result = FAILRULE_BIT;

return ptr;

}

strcpy(buffer, QUOTEDFNVAR(word ));

}

else StdNumber(word, buffer, controls);

return ptr;

}

static char* Output_String(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result)

{

// handles function string: (char*)"^ .... " which means go eval the contents of the string

// handles simple string: (char*)"this is a string" which means just put it out (with or without quotes depending on controls)

// handles compiled strings: "^:xxx" which means formatting has already been performed (function arguments)

size_t len;

if (controls & OUTPUT_UNTOUCHEDSTRING && word[1] != FUNCTIONSTRING) strcpy(buffer, word); //functions take untouched strings typically

else if (word[1] == FUNCTIONSTRING) // treat as format string

{

if (!dictionaryLocked) strcpy(buffer, word); // untouched - function strings passed as arguments to functions are untouched until used up. - need untouched so can create facts from tables with them in it

else ReformatString(*word, word + 2, buffer, result, controls);

}

else if (controls & OUTPUT_NOQUOTES)

{

strcpy(buffer, word + 1);

len = strlen(buffer);

if (buffer[len - 1] == '"') buffer[len - 1] = 0; // remove end quote

}

else strcpy(buffer, word); // untouched - function strings passed as arguments to functions are untouched until used up. - need untouched so can create facts from tables with them in it

return ptr;

}

static char* Output_Underscore(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result, bool once)

{

// handles wildcard assigment: _10 = hello

// handles wildcard: _19

// handles simple _ or _xxxx

if (!once && IsAssignmentOperator(ptr)) ptr = PerformAssignment(word, ptr, buffer, result);

else if (IsDigit(word[1])) // wildcard

{

int id = GetWildcardID(word);

if (id >= 0)

{

StdNumber(wildcardCanonicalText[id], buffer, controls);

if (controls & OUTPUT_NOQUOTES && *buffer == '"') // remove quotes from match variable's data

{

size_t len = strlen(buffer);

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

{

buffer[len - 1] = 0;

memmove(buffer, buffer + 1, len);

}

}

if (*buffer == '^' && IsAlphaUTF8(buffer[1]) && *SkipWhitespace(ptr) == '(') *word = ENDUNIT; // if fn call substituted, force reeval

}

}

else strcpy(buffer, word); // stand-alone _ or some non wildcard

return ptr;

}

static char* Output_Dollar(char* word, char* ptr, char* space, char*& buffer, unsigned int controls, FunctionResult & result, bool once, bool nojson)

{

// handles user variable assignment: $myvar = 4

// handles user variables: $myvar

// handles US money: $1000.00

if ((word[1] == '$' || word[1] == '_') && !word[2]) StdNumber(word, buffer, controls); // simple $_ or $$

else if (word[1] && !IsDigit(word[1])) // variable

{

if (controls & OUTPUT_EVALCODE && !(controls & OUTPUT_KEEPVAR))

{

char* answer = GetUserVariable(word, nojson);

if (*answer == USERVAR_PREFIX && (answer[1] == LOCALVAR_PREFIX || answer[1] == TRANSIENTVAR_PREFIX || IsAlphaUTF8(answer[1]))) strcpy(word, answer); // force nested indirect on var of a var value

}

if (!once && IsAssignmentOperator(ptr))

ptr = PerformAssignment(word, ptr, buffer, result);

else

{

char* at1 = word;

while (*at1 == '_' || *at1 == '$') ++at1;

while (*++at1)

{

if (IsLegalNameCharacter(*++at1) || *at1 == '.' || *at1 == '[' || *at1 == ']' || *at1 == '$'); // find real end of var allowing json references

else if (*at1 == '\\'); // escaped variable so not considered variable, its actually the name

else if ((*at1 == '$') && (*(at1 - 1) == '[' || *(at1 - 1) == '.')) { ; } // allowed variable json ref

else break;

}

if (at1 && *at1)

{

*at1 = 0;

size_t len = at1 - word;

ptr = ptr - len;

}