#include "common.h"

#include "evserver.h"

extern SYSTEMVARIABLE sysvars[];

char* compileDate = __DATE__ " " __TIME__;

static char systemValue[MAX_WORD_SIZE]; // common answer place

////////////////////////////////////////////////////

/// OVERVIEW CODE

////////////////////////////////////////////////////

char dbparams[MAX_WORD_SIZE*4];

void InitSystemVariables()

{

*dbparams = 0;

unsigned int i = 0;

while (sysvars[++i].name)

{

if (sysvars[i].name[0] == SYSVAR_PREFIX)

{

StoreWord((char*) sysvars[i].name)->x.topicIndex = (unsigned short) i; // not a header

(*sysvars[i].address)((char*)"."); // force a reset-- testing calls this to reset after changes

}

}

}

char* SystemVariable(char* word,char* value)

{

WORDP D = FindWord(word);

unsigned int index = (D) ? D->x.topicIndex : 0;

if (!index) return "";

char* var = (*sysvars[index].address)(value); // performs assignment

if (!var) return "";

return var;

}

void DumpSystemVariables()

{

unsigned int i = 0;

while (sysvars[++i].name)

{

char* result = (sysvars[i].address) ? (*sysvars[i].address)(NULL) : (char*)""; // actual variable or header

if (!*result)

{

if (strstr(sysvars[i].comment,(char*)"Boolean")) result = "null";

else if (strstr(sysvars[i].comment,(char*)"Numeric")) result = "0";

else result = "null";

}

if (sysvars[i].address) Log(USERLOG,"%s = %s - %s\r\n",sysvars[i].name, result,sysvars[i].comment); // actual variable

else Log(USERLOG,"%s\r\n",sysvars[i].name); // header

}

}

static char* AssignValue(char* hold, char* value)

{

if (value[0] == value[1] && value[1] == '"') *value = 0; // null string

else if (!stricmp(value,(char*)"NULL") ) *value = 0;

strcpy(hold,value);

return hold;

}

////////////////////////////////////////////////////

/// TIME AND DATE

////////////////////////////////////////////////////

static char* Sdate(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "1";

struct tm ptm;

char* x = GetTimeInfo(&ptm) + 8;

ReadCompiledWord(x,systemValue);

return systemValue; // 1 or 2 digit date

}

static char* SdayOfWeek(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "Monday";

struct tm ptm;

ReadCompiledWord(GetTimeInfo(&ptm),systemValue);

switch(systemValue[1])

{

case 'o': return "Monday";

case 'u': return (char*)((systemValue[0] == 'T') ? (char*)"Tuesday" : (char*)"Sunday");

case 'e': return "Wednesday";

case 'h': return "Thursday";

case 'r': return "Friday";

case 'a': return "Saturday";

}

return "";

}

static char* SdayNumberOfWeek(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "2";

struct tm ptm;

ReadCompiledWord(GetTimeInfo(&ptm),systemValue);

int n;

switch(systemValue[1])

{

case 'u': n = (systemValue[0] != 'T') ? 1 : 3; break;

case 'o': n = 2; break;

case 'e': n = 4; break;

case 'h': n = 5; break;

case 'r': n = 6; break;

case 'a': n = 7; break;

default: n = 0; break;

}

systemValue[0] = (char)(n + '0');

systemValue[1] = 0;

return systemValue;

}

char* SFullTime(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

uint64 curr = (uint64) time(0);

if (regression) curr = 44444444;

sprintf(systemValue,(char*)"%s",PrintU64(curr));

return systemValue;

}

static char* SStartTimeMS(char* value)

{

// full time in milliseconds

static char hold[50] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

sprintf(systemValue, (char*)"%llu", callStartTime);

return systemValue;

}

static char* SFullTimeMS(char* value)

{

// full time in milliseconds

static char hold[50] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

uint64 elapsedMS = ElapsedMilliseconds();

sprintf(systemValue, (char*)"%llu", elapsedMS);

return systemValue;

}

static char* Shour(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "11";

struct tm ptm;

strncpy(systemValue,GetTimeInfo(&ptm)+11,2);

systemValue[2] = 0;

return systemValue;

}

static char* SleapYear(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "";

time_t rawtime;

time (&rawtime );

struct tm timeinfo;

mylocaltime (&rawtime,&timeinfo );

int year = timeinfo.tm_year + 1900;

bool leap = false;

if ((year % 400) == 0) leap = true;

else if ((year % 100) != 0 && (year % 4) == 0) leap = true;

return leap ? (char*)"1" : (char*)"";

}

static char* Sdaylightsavings(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "1";

time_t rawtime;

time (&rawtime );

struct tm timeinfo;

mylocaltime (&rawtime,&timeinfo );

int dst = timeinfo.tm_isdst;

return dst ? (char*)"1" : (char*)"";

}

static char* Sminute(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "12";

struct tm ptm;

ReadCompiledWord(GetTimeInfo(&ptm)+14,systemValue);

systemValue[2] = 0;

return systemValue;

}

static char* Smonth(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "6";

struct tm ptm;

ReadCompiledWord(GetTimeInfo(&ptm)+SKIPWEEKDAY,systemValue);

switch(systemValue[0])

{

case 'J': // january june july

if (systemValue[1] == 'a') return "1";

else if (systemValue[2] == 'n') return "6";

else if (systemValue[2] == 'l') return "7";

break;

case 'F': return "2";

case 'M': return (systemValue[2] != 'y') ? (char*)"3" : (char*)"5";

case 'A': return (systemValue[1] == 'p') ? (char*)"4" : (char*)"8";

case 'S': return "9";

case 'O': return "10";

case 'N': return "11";

case 'D': return "12";

}

return "";

}

static char* SmonthName(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "June";

struct tm ptm;

ReadCompiledWord(GetTimeInfo(&ptm)+SKIPWEEKDAY,systemValue);

switch(systemValue[0])

{

case 'J': // january june july

if (systemValue[1] == 'a') return "January";

else if (systemValue[2] == 'n') return "June";

else if (systemValue[2] == 'l') return "July";

break;

case 'F': return "February";

case 'M': return (systemValue[2] != 'y') ? (char*)"March" : (char*)"May";

case 'A': return (systemValue[1] == 'p') ? (char*)"April" : (char*)"August";

case 'S': return "September";

case 'O': return "October";

case 'N': return "November";

case 'D': return "December";

}

return "";

}

static char* Ssecond(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "12";

struct tm ptm;

ReadCompiledWord(GetTimeInfo(&ptm)+17,systemValue);

systemValue[2] = 0;

return systemValue;

}

static char* Svolleytime(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "12";

uint64 diff = ElapsedMilliseconds() - volleyStartTime;

sprintf(systemValue,(char*)"%u",(unsigned int)diff);

return systemValue;

}

static char* Stime(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "01:40";

struct tm ptm;

strncpy(systemValue,GetTimeInfo(&ptm)+11,5);

systemValue[5] = 0;

return systemValue;

}

static char* Szulutime(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

struct tm ptm;

GetTimeInfo(&ptm,true,true);

uint64 elapsedMS = ElapsedMilliseconds();

sprintf(systemValue,(char*)"%d-%2.2d-%2.2dT%2.2d:%2.2d:%2.2d.%3.3dZ",ptm.tm_year+1900,ptm.tm_mon+1,ptm.tm_mday,

ptm.tm_hour,ptm.tm_min,ptm.tm_sec, (int)(elapsedMS%1000));

return systemValue;

}

static char* Stimenumbers(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

struct tm ptm;

GetTimeInfo(&ptm);

sprintf(systemValue,(char*)"%2.2d %2.2d %2.2d %d %d %d %d",ptm.tm_sec,ptm.tm_min, ptm.tm_hour, ptm.tm_wday, ptm.tm_mday, ptm.tm_mon, ptm.tm_year+1900);

return systemValue;

}

static char* SweekOfMonth(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "1";

int n;

struct tm ptm;

char* x = GetTimeInfo(&ptm) + 8;

if (*x == ' ') ++x; // Mac uses space, pc uses 0 for 1 digit numbers

ReadInt(x,n);

systemValue[0] = (char)('0' + (n/7) + 1);

systemValue[1] = 0;

return systemValue;

}

static char* Syear(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (regression) return "2017";

struct tm ptm;

ReadCompiledWord(GetTimeInfo(&ptm)+20,systemValue);

return (regression) ? (char*)"1951" : systemValue;

}

static char* Srand(char* value) // 1 .. 100

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (forcedRandom>= 0)

{

sprintf(systemValue, (char*)"%i", forcedRandom);

return systemValue;

}

if (regression) return "0";

sprintf(systemValue,(char*)"%u",random(100)+1);

return systemValue;

}

////////////////////////////////////////////////////

/// SYSTEM

////////////////////////////////////////////////////

static char* Sall(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

return (all != 0) ? (char*)"1" : (char*)"";

}

static char* Sscript(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (topicBlockPtrs[2]) sprintf(systemValue,(char*)"Script1: %s Script0: %s Script2: %s",timeStamp[1],timeStamp[0],timeStamp[2]);

else sprintf(systemValue,(char*)"Script1: %s Script0: %s",timeStamp[1],timeStamp[0]);

return systemValue;

}

static char* Sengine(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"Engine: %s",compileDate);

if (systemValue[12] == ' ') systemValue[12] = '0';

return systemValue;

}

static char* Sip(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

strcpy(systemValue,ipAddress);

return systemValue;

}

static char* Slanguage(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

strcpy(systemValue, current_language);

return systemValue;

}

static char* Sos(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

#ifdef WIN32

strcpy(systemValue,(char*)"windows");

#elif __MACH__

strcpy(systemValue,(char*)"mac");

#elif IOS

strcpy(systemValue,(char*)"ios");

#elif ANDROID

strcpy(systemValue,(char*)"android");

#else

strcpy(systemValue,(char*)"linux");

#endif

return systemValue;

}

char* Slogging(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

sprintf(systemValue, "%d %d %s ",serverLog, userLog, hostname);

return systemValue;

}

static char* Suser(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

strcpy(systemValue,loginID);

return systemValue;

}

static char* Sdbparams(char* value)

{

static char hold[1000] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

return dbparams;

}

static char* Sbot(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

strcpy(systemValue,computerID);

return systemValue;

}

static char* Sbotid(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

sprintf(systemValue, "%u", (unsigned int)myBot);

return systemValue;

}

static char* Sdict(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"Dictionary: %s",dictionaryTimeStamp);

return systemValue;

}

static char* StableInput(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

return (tableinput) ? tableinput : (char*)"";

}

static char* SfactExhaustion(char* value)

{

static char hold[50] = ".";

if (value)

{

if (!stricmp(value, "false")) factsExhausted = false;

else return AssignValue(hold, value);

}

if (*hold != '.') return hold;

return (factsExhausted) ? (char*)"1" : (char*)"";

}

static char* StsvSource(char* value)

{

static char hold[50] = ".";

if (value)

{

return AssignValue(hold, value);

}

if (*hold != '.') return hold;

return (tsvFile) ? (char*)"1" : (char*)"";

}

static char* Sversion(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"Version: %s %s",version, buildString);

return systemValue;

}

#ifndef DISCARDJSONOPEN

static char* Scurlversion(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"%s",CurlVersion());

return systemValue;

}

#endif

static char* Sdbversion(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"");

#ifndef DISCARDMYSQL

strcat(systemValue,MySQLVersion());

strcat(systemValue,(char*)" ");

#endif

#ifndef DISCARDMICROSOFTSQL

strcat(systemValue,MsSqlVersion());

strcat(systemValue,(char*)" ");

#endif

#ifndef DISCARDPOSTGRES

strcat(systemValue,PostgresVersion());

strcat(systemValue,(char*)" ");

#endif

#ifndef DISCARDMONGO

strcat(systemValue,MongoVersion());

strcat(systemValue,(char*)" ");

#endif

return systemValue;

}

static char* Sfact(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"%u",Fact2Index(lastFactUsed));

return systemValue;

}

static char* Shost(char* value)

{

static char hold[50] = ".";

if (value)

{

if (*value != '.') regression = *value != '0';

return strcpy(hold,value);

}

if (*hold != '.') return hold;

return hostname;

}

static char* Sregression(char* value)

{

static char hold[50] = ".";

if (value)

{

if (*value != '.') regression = *value != '0';

return strcpy(hold,value);

}

if (*hold != '.') return hold;

return (regression != 0) ? (char*)"1" : (char*)"";

}

static char* ShttpResponse(char* value)

{

static char hold[50] = ".";

if (value)

{

if (*value != '.') regression = *value != '0';

return strcpy(hold,value);

}

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"%d",(int)http_response);

return systemValue;

}

static char* Slastcurltime(char* value)

{

static char hold[100] = ".";

if (value)

{

if (*value != '.') regression = *value != '0';

return strcpy(hold,value);

}

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"%s",lastcurltime);

return systemValue;

}

static char* SmaxMatchVariables(char* value)

{

static char hold[50] = ".";

if (value)

{

if (*value != '.') regression = *value != '0';

return strcpy(hold,value);

}

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"%d",MAX_WILDCARDS);

return systemValue;

}

static char* SmaxFactSets(char* value)

{

static char hold[50] = ".";

if (value)

{

if (*value != '.') regression = *value != '0';

return strcpy(hold,value);

}

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"%d",MAX_FIND_SETS);

return systemValue;

}

static char* Sspeaker(char* value)

{

static char hold[4000];

if (value)

{

size_t len = strlen(value);

if (len >= 4000) value[len - 1] = 0;

strcpy(hold, value);

}

return (*hold != '.') ? hold : speaker;

}

static char* ScrossTalk(char* value)

{

static char hold[4000];

if (value)

{

size_t len = strlen(value);

if (len >= 4000) value[len-1] = 0;

strcpy(hold,value);

}

return (*hold != '.') ? hold : (char*)"";

}

static char* ScrossTalk1(char* value)

{

static char hold[4000];

if (value)

{

size_t len = strlen(value);

if (len >= 4000) value[len - 1] = 0;

strcpy(hold, value);

}

return (*hold != '.') ? hold : (char*)"";

}

static char* ScrossTalk2(char* value)

{

static char hold[4000];

if (value)

{

size_t len = strlen(value);

if (len >= 4000) value[len - 1] = 0;

strcpy(hold, value);

}

return (*hold != '.') ? hold : (char*)"";

}

static char* ScrossTalk3(char* value)

{

static char hold[4000];

if (value)

{

size_t len = strlen(value);

if (len >= 4000) value[len - 1] = 0;

strcpy(hold, value);

}

return (*hold != '.') ? hold : (char*)"";

}

static char* Sdocument(char* value)

{

static char hold[50] = ".";

if (value) return strcpy(hold,value); // may not legall set on one's own

if (*hold != '.') return hold;

return (documentMode != 0) ? (char*)"1" : (char*)"";

}

static char* SfreeText(char* value)

{

static char hold[50] = ".";

if (value) return strcpy(hold,value); // may not legally set on one's own

int nominalUsed = maxHeapBytes - (heapBase - heapFree);

sprintf(hold,(char*)"%d",nominalUsed / 1000);

return hold;

}

static char* SfreeWord(char* value)

{

static char hold[50] = ".";

if (value) return strcpy(hold,value); // may not legally set on one's own

sprintf(hold,(char*)"%lu",((unsigned int)maxDictEntries)-(dictionaryFree-dictionaryBase));

return hold;

}

static char* SfreeFact(char* value)

{

static char hold[50] = ".";

if (value) return strcpy(hold,value); // may not legally set on one's own

sprintf(hold,(char*)"%ld",factEnd-lastFactUsed);

return hold;

}

static char* Srule(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (currentTopicID == 0 || currentRuleID == -1) return "";

sprintf(systemValue,(char*)"%s.%u.%u",GetTopicName(currentTopicID),TOPLEVELID(currentRuleID),REJOINDERID(currentRuleID));

return systemValue;

}

static char* StestPattern(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (testPatternIndex == -1) return "";

sprintf(systemValue,(char*)"%d",testPatternIndex);

return systemValue;

}

static char* Sserver(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (!server) return "";

sprintf(systemValue,(char*)"%u",port);

return systemValue;

}

static char* SmyIP(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

return myip;

}

static char* Stopic(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

GetActiveTopicName(systemValue);

return systemValue;

}

static char* SactualTopic(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

strcpy(systemValue,GetTopicName(currentTopicID,false));

return systemValue;

}

static char* STrace(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (!trace) return "0";

sprintf(systemValue,(char*)"%u",trace);

return systemValue;

}

static char* SPID(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

#ifdef LINUX

sprintf(systemValue,(char*)"%d",getpid());

#elif __MACH__

sprintf(systemValue,(char*)"%d",getpid());

#else

sprintf(systemValue,(char*)"%d",0);

#endif

return systemValue;

}

static char* SForkCount(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (!server) return (char*)"";

#ifdef EVSERVER_FORK

sprintf(systemValue,(char*)"%d",forkcount);

#else

sprintf(systemValue,(char*)"%d",0);

#endif

return systemValue;

}

static char* SServerType(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

if (!server) return (char*)"";

#ifdef EVSERVER_FORK

if (no_children_g > 0) return parent_g ? (char*)"parent" : (char*)"fork";

#endif

return (char*)"server";

}

static char* SRestart(char* value)

{

static char systemRestartValue[MAX_WORD_SIZE]; // restart passback

static bool inited = false;

if (!inited)

{

inited = true;

*systemRestartValue = 0;

}

if (value && *value == '.') return ""; // ignore init

else if (value)

{

if (strlen(value) >= MAX_WORD_SIZE) value[MAX_WORD_SIZE-1] = 0;

strcpy(systemRestartValue,value);

return "";

}

else return systemRestartValue;

}

static char* STimeout(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

return timerCheckInstance == TIMEOUT_INSTANCE ? (char*)"1" : (char*)"";

}

static char* SHeapSize(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold, value);

if (*hold != '.') return hold;

int d = (heapFree - stackFree);

sprintf(systemValue,"%d", d);

return systemValue;

}

////////////////////////////////////////////////////

/// USER INPUT

////////////////////////////////////////////////////

static char* Sforeign(char* value)

{

static char hold[50] = ".";

if (value)

{

if (*value == '.') strcpy(hold,value);

else if (!stricmp(value,(char*)"1")) tokenFlags |= FOREIGN_TOKENS;

else if (!stricmp(value,(char*)"0")) tokenFlags &= -1 ^ FOREIGN_TOKENS;

}

if (*hold != '.') return hold;

return tokenFlags & FOREIGN_TOKENS ? (char*)"1" : (char*)"";

}

static char* Sinput(char* value)

{

static char hold[50] = ".";

if (value)

{

if (value[0] != '.') volleyCount = atoi(value); // actually changes it

else strcpy(hold,value);

}

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"%u",volleyCount);

return systemValue;

}

static char* Slength(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

sprintf(systemValue,(char*)"%u",wordCount);

return systemValue;

}

static char* Smore(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

return moreToCome ? (char*)"1" : (char*)"";

}

static char* SmoreQuestion(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

return moreToComeQuestion ? (char*)"1" : (char*)"";

}

static char* sentencehold = NULL;

char* SoriginalInput(char* value)

{

if (csapicall == TEST_PATTERN) return testpatterninput;

static char hold[50] = ".";

if (value)

{

if (*value == '.' && !value[1]) sentencehold = NULL; // end use by testpattern

else if (strlen(value) > 45)

{

sentencehold = value; // from testpattern

return value;

}

return AssignValue(hold, value);

}

if (*hold != '.') return hold; // simple override

if (sentencehold) return sentencehold;// testpattern override for long inputs

return originalUserMessage;

}

static char* SoriginalSentence(char* value)

{

static char hold[50] = ".";

if (value)

{

if (*value == '.' && !value[1]) sentencehold = NULL; // end use by testpattern

else if (strlen(value) > 45)

{

sentencehold = value; // from testpattern

return value;

}

return AssignValue(hold, value);

}

if (*hold != '.') return hold; // simple override

if (sentencehold) return sentencehold;// testpattern override for long inputs

return rawSentenceCopy; // normal actual initial input

}

static char* Sparsed(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

return tokenFlags & FAULTY_PARSE ? (char*)"" : (char*)"1";

}

static char* Ssentence(char* value)

{

static char hold[50] = ".";

if (value) return AssignValue(hold,value);

if (*hold != '.') return hold;

return tokenFlags & NOT_SENTENCE ? (char*)"" : (char*)"1";

}

static char* Squestion(char* value)

{

static char hold[50] = ".";

if (value)

{

if (*value == '.') strcpy(hold,value);