#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* 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* oldOutputRuleBase[MAX_OUTPUT_NEST];

static unsigned int oldOutputLimit[MAX_OUTPUT_NEST];

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 compiled and 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;

else control |= OUTPUT_ONCE | OUTPUT_NOCOMMANUMBER;

ptr = Output(ptr,buffer,result,control); // no additional buffering needed

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;

}

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;

}

bool LegalVarChar(char at)

{

return (IsAlphaUTF8OrDigit(at) || at == '_' || at == '-' );

}

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) == '.'))

{

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

{

if (!LegalVarChar(input[1]) && input[1] != '$' && input[1] != '[') 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;

#ifdef WIN32

sprintf(buffer,(char*)"%I64d",(long long int) n);

#else

sprintf(buffer,(char*)"%lld",(long long int) n);

#endif

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

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

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

char level = 0;

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

{

level = *ptr;

ptr += 3; // skip special rejoinder

}

Output(ptr,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(STDTRACELOG,(char*)"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 item and 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

tokens and 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

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

}

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

return ptr;

}

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

{

// handles newline: \n

// 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] == 'r' && !word[2])

{

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

return ptr;

}

if (word[1] == 'n') // \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

start[len] = 0;

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

}

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])) // function variable

{

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

else

{

char* value = callArgumentList[atoi(word+1)+fnVarBase];

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

}

}

}

}

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

{

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

{

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

if (word[1] == USERVAR_PREFIX) // direct retry to avoid json issues

{

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

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

}

else *word = ENDUNIT; // marker for retry

}

}

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

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

else if (word[1] == '^') // if and loop

{

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;

}

else // functions or ordinary words

{

if (*ptr != '(' || !word[1])

{

strcpy(buffer,word); // a non function

}

else // ordinary function

{

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") )) // 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_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 ^

{

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

*word = '^'; // supply ^

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

if (result == UNDEFINED_FUNCTION) // wasnt a function after all.

{

result = NOPROBLEM_BIT;

StdNumber(word+1,buffer,controls);

}

}

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)

{

ARGUMENT(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*)"%d",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(callArgumentList[atoi(word+2)+fnVarBase]);

size_t size = (buffer - currentOutputBase);

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

{

result = FAILRULE_BIT;

return ptr;

}

strcpy(buffer,callArgumentList[atoi(word+2)+fnVarBase]);

}

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 variable 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* value = GetUserVariable(word,nojson);

StdNumber(value,buffer,controls);

char* at = SkipWhitespace(buffer);

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

{

size_t len = strlen(at);

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

{

at[len-1] = 0;

memmove(at,at+1,len);

}

}

if (*at == '"' && at[1] == FUNCTIONSTRING) *word = ENDUNIT; // reeval the function string

}

}

else StdNumber(word,buffer,controls); // money or simple $

return ptr;

}

char* Output(char* ptr,char* buffer,FunctionResult &result,int controls)

{ // moves any special stuff to front of buffer

// an output stream consists of words, special words, [] random zones, commands, C-style script. It autoformats whitespace.

*buffer = 0;

char* start = buffer;

result = NOPROBLEM_BIT;

if (*ptr == ENDUNIT && ptr[1] == ENDUNIT) ptr += 2; // skip over a transient $_ marker

if (!*ptr) return NULL;

bool once = false;

if (controls & OUTPUT_ONCE) // do one token

{

once = true;

controls ^= OUTPUT_ONCE;

}

if (buffer < currentOutputBase || (size_t)(buffer - currentOutputBase) >= (size_t)(currentOutputLimit-200)) // output is wrong or in danger already?

{

result = FAILRULE_BIT;

return ptr;

}

char* word = AllocateBuffer("output"); // allocation from stack doesnt work for unknown reason

bool quoted = false;

char* startQuoted = NULL;

// nested depth assignments from our heap space

int paren = 0;

while (ptr)

{

if (!*start) buffer = start; // we may have built up a lot of buffer, then flushed it along the way. If so, drop back to start to continue.

char* space = NULL;

*buffer = 0;

ptr = SkipWhitespace(ptr); // functions no longer skip blank after end, in case being used by reformat and preserving the space

if (!*ptr || (*ptr == ENDUNIT && ptr[1] != ENDUNIT)) break; // out of data

char* priorPtr = ptr;

ptr = ReadCompiledWord(ptr,word,false,true); // stop when $var %var _var @nvar end normally- insure no ) ] } lingers on word in case it wasnt compiled

if (*word == '$' && *ptr == '[' && ptr[1] == ']') // merge $word[]

{

strcat(word, "[]");

ptr += 2;

}

if (*word == '/' && ptr[0] == '(') continue; // JA PATCH for mistaken /(OS)

char* startptr = ptr;

ptr = SkipWhitespace(ptr); // find next token to tes for assignment and the like

if (!*word && !paren ) break; // end of data or choice or body

if (!(controls & OUTPUT_RAW) && (*word == ')' || *word == ']' || *word == '}') && !paren ) break; // end of data or choice or body

if (*word == '[' && word[1]) // break apart uncompiled choice

{

ptr = SkipWhitespace(priorPtr) + 1;

word[1] = 0;

}

else if (*word == FUNCTIONSTRING && (word[1] == '"' || word[1] == '\'' ) ) {;} // function strings can all sorts of stuff in them

else if ((*word == '"') && word[1] == FUNCTIONSTRING) {;} // function strings can all sorts of stuff in them

else if (*word != '$') // separate closing brackets from token in case not run thru script compilation

{

bool quote = false;

char* at = word-1;

while (*++at )

{

if (*at == '\\')

{

++at; // skip over next character

continue;

}

if (*at == '"') quote = !quote;

if (quote) continue; // ignore inside a quote

if (*at == ']' || *at == ')' || *at == '}') break; // was not backslash quoted item

}

if (*at && at != word) // tail-- remove if not literalized

{

ptr = priorPtr + (at - word);

*at = 0;

}

}

// determine whether to space before item or not. Don't space at start but normally space after existing output tokens with exceptions.

if (start != buffer)

{

bool allow = true;

char c = *(buffer-1);

if (quoted && buffer == startQuoted) // first thingy after \"