extern void _cdecl StrTrim(LPSTR str, LPSTR trimChars)
{
unsigned int start = 0;
unsigned int end = strlen(str) - 1;
for (unsigned int i = 0; i < end; i++) {
char c = str[i];
if (!StrContains(trimChars, c)) {
start = i;
break;
}
}
for (int i = end; i >= 0; i--) {
char c = str[i];
if (!StrContains(trimChars, c)) {
end = i;
break;
}
}
if (start != 0 || end != strlen(str) - 1) {
int k = 0;
for (unsigned int i = start; i <= end; i++, k++) {
str[k] = str[i];
}
str[k] = 0;
}
}
void GetCharMap(char key[]) //得到常规字母表关于密钥key的映射表，即为用来加密的有效对应表
{
int k = 97;
for(int i = 0;i < 26;i++) //循环26次
{
if(i < strlen(key)) //如果下标比key的长度小，直接赋值
{
afterMap[i] = key[i];
}
else //否则按照从字母表中补字母的方法来做
{
for(int j = k;j < 97 + 26;j++) //j的初值为k=97（也就是a），以后k的值会变化
{
if(StrContains(key,j)) //如果j已在key中出现，则不算数，继续做
{
continue;
}
else //否则，说明key中不包含j，直接赋值
{
afterMap[i] = j;
k = j + 1; //之后k的值会加1，保证下次赋值时不会重复前面的字母
break;
}
}
}
}
}
void INI::ParseRegistryKeys(dictionary* ini)
{
// Now check if we have a registry location to load from
char* iniRegistryLocation = iniparser_getstr(ini, INI_REGISTRY_LOCATION);
if(!iniRegistryLocation) {
return;
}
Log::Info("Loading INI keys from registry: %s", iniRegistryLocation);
// find root key
int len = strlen(iniRegistryLocation);
int slash = 0;
while(slash < len && iniRegistryLocation[slash] != '\\')
slash++;
if(slash == len) {
Log::Warning("Unable to parse registry location (%s) - keys not included", iniRegistryLocation);
return;
}
HKEY hKey = 0;
char* rootKey = strdup(iniRegistryLocation);
rootKey[slash] = 0;
if(strcmp(rootKey, "HKEY_LOCAL_MACHINE") == 0) {
hKey = HKEY_LOCAL_MACHINE;
} else if(strcmp(rootKey, "HKEY_CURRENT_USER") == 0) {
hKey = HKEY_CURRENT_USER;
} else if(strcmp(rootKey, "HKEY_CLASSES_ROOT") == 0) {
hKey = HKEY_CLASSES_ROOT;
} else {
Log::Warning("Unrecognized registry root key: %s", rootKey);
free(rootKey);
return;
}
free(rootKey);
HKEY subKey;
if(RegOpenKeyEx(hKey, &iniRegistryLocation[slash+1], 0, KEY_READ, &subKey) != ERROR_SUCCESS) {
Log::Warning("Unable to open registry location (%s)", iniRegistryLocation);
return;
}
DWORD index = 0;
char name[MAX_PATH + 2];
char data[4096];
DWORD type;
DWORD nameLen = MAX_PATH;
DWORD dataLen = 4096;
name[0] = ':';
while(RegEnumValue(subKey, index, &name[1], &nameLen, NULL, &type, (LPBYTE) data, &dataLen) == ERROR_SUCCESS) {
bool hasNamespace = StrContains(&name[1], ':');
char* key = hasNamespace ? &name[1] : name;
if(type == REG_DWORD) {
DWORD val = *((LPDWORD)data);
sprintf(data, "%d", val);
iniparser_setstr(ini, key, data);
} else if(type == REG_SZ && dataLen > 1) {
iniparser_setstr(ini, key, data);
}
nameLen = MAX_PATH;
dataLen = 4096;
index++;
}
}
void CExpression::Validate(int& chpos)
{
chpos = -1;
ExpToken curTok;
ExpToken prevTok;
// Null entry not allowed
if (toks.empty()) {
chpos = 0;
throw runtime_error("You must enter an expression");
}
// If first or last tokens are a binary operator, disallow
if (TokenFitsRule(toks.front().t, T_ANY_BINARY_OPERATOR) || toks.front().t == T_DOT) {
chpos = TokenToChar(0);
CString msg = "'";
msg += toks.front().str;
msg += "' not valid here";
throw runtime_error((const char*)msg);
}
// If first or last tokens are a binary operator, disallow
if (TokenFitsRule(toks.back().t, T_ANY_BINARY_OPERATOR) || toks.back().t == T_DOT) {
chpos = TokenToChar((int)toks.size() - 1);
CString msg = "'";
msg += toks.back().str;
msg += "' not valid here";
throw runtime_error((const char*)msg);
}
int LBrackets = 0, RBrackets = 0, LastLBracket = 0, LastRBracket = 0;
int LBrackets2 = 0, RBrackets2 = 0, LastLBracket2 = 0, LastRBracket2 = 0;
for (int i = 0; i < toks.size(); i++) {
if (toks[i].t == T_LEFTBRACKET) {
LBrackets++;
LastLBracket = i;
}
if (toks[i].t == T_RIGHTBRACKET) {
RBrackets++;
LastRBracket = i;
// Too many close brackets
if (RBrackets > LBrackets) {
chpos = TokenToChar(i);
throw runtime_error("Too many close brackets");
}
}
if (toks[i].t == T_LEFTCURLY) {
LBrackets2++;
LastLBracket2 = i;
}
if (toks[i].t == T_RIGHTCURLY) {
RBrackets2++;
LastRBracket2 = i;
// Too many close brackets
if (RBrackets2 > LBrackets2) {
chpos = TokenToChar(i);
throw runtime_error("Too many closing '}'");
}
}
// Identifier token
if (i == 0 || toks[i-1].t != T_DOT)
if (toks[i].t == T_IDENTIFIER) {
// Tokens follow
if (i + 1 < toks.size()) {
// Not part of object.*
if (toks[i+1].t != T_DOT) {
// Invalid unless sys exp
if (!SystemExpressionExists(toks[i].str) && !ObjectHasDefaultValue(toks[i].str)) {
chpos = TokenToChar(i);
CString err = "'";
err += toks[i].str;
err += "' is not a recognised system expression or usable object name.";
throw runtime_error((const char*)err);
}
}
// Next token is dot: check object name exists
else if (!ObjectNameExists(toks[i].str) && !StrContains(toks[i].str, '[')) {
chpos = TokenToChar(i);
CString err = "'";
err += toks[i].str;
err += "' is not an object name";
throw runtime_error((const char*)err);
}
}//if not last token
// Last token
else {
// Invalid unless sys exp
if (!SystemExpressionExists(toks[i].str) && !ObjectHasDefaultValue(toks[i].str) && !StrContains(toks[i].str, '[')) {
chpos = TokenToChar(i);
CString err = "'";
err += toks[i].str;
err += "' is not a recognised expression";
throw runtime_error((const char*)err);
}
}
}//if identifier
// Rest of code is not safe for i=0
if (i == 0) continue;
// If identifier preceded by dot
if (toks[i].t == T_IDENTIFIER && toks[i-1].t == T_DOT) {
// Check expression name exists
if (!ObjectExpressionExists(toks[i-2].str, toks[i].str)) {
chpos = TokenToChar(i);
CString err = "'";
err += toks[i].str;
err += "' is not an expression in '";
err += toks[i-2].str;
err += "'";
throw runtime_error((const char*)err);
}
}
curTok = toks[i].t;
prevTok = toks[i - 1].t;
int rule = GetRuleForToken(prevTok);
int step = 1;
bool allowed = false;
while (ExpValidationRules[rule][step] != T_NULL) {
if (TokenFitsRule(curTok, ExpValidationRules[rule][step])) {
allowed = true;
break;
}
step++;
}//while
// This token combo not allowed
if (!allowed) {
CString err = "'";
err += toks[i].str;
err += "' is not allowed after '";
err += toks[i-1].str;
err += "'";
chpos = TokenToChar(i);
throw runtime_error((const char*)err);
}
}//for
// Some unclosed brackets
if (LBrackets > RBrackets) {
// Find the unclosed bracket
int LBracketNumber = 0;
int tokenNumber = 0;
int i;
for (i = toks.size() - 1; i >= 0; i--) {
if (toks[i].t == T_LEFTBRACKET)
LBracketNumber--;
if (toks[i].t == T_RIGHTBRACKET)
LBracketNumber++;
if (LBracketNumber == -1)
break;
}
chpos = TokenToChar(i);
throw runtime_error("Too many open brackets");
}
// Some unclosed brackets
if (LBrackets2 > RBrackets2) {
// Find the unclosed bracket
int LBracketNumber = 0;
int tokenNumber = 0;
int i;
for (i = toks.size() - 1; i >= 0; i--) {
if (toks[i].t == T_LEFTCURLY)
LBracketNumber--;
if (toks[i].t == T_RIGHTCURLY)
LBracketNumber++;
if (LBracketNumber == -1)
break;
}
chpos = TokenToChar(i);
throw runtime_error("Too many opening '{'");
}
}
// Tokenise a user's typed expression string
void CExpression::ParseUserString(const char* exp, int* pchpos, bool editorMode)
{
toks.clear();
whitespaceCount = 0;
// Loop every char
for (int i = 0; exp[i] != NULL; i++) {
if (pchpos) *pchpos = i;
char NextCh = exp[i+1];
char CurCh = exp[i];
char PrevCh = exp[(i == 0 ? 0 : i-1)];
char strbuf[128];
// Check this char
switch (exp[i]) {
case '+':
AppendToken(T_ADD, "+");
break;
case '-':
// If previous token is not operand, use as negative sign
// Fix 25/4/07: random(4) - random(5) interprets '-' as integer: explicit check for right bracket
if (toks.size() == 0 || ((!TokenFitsRule(toks.back().t, T_ANY_VALUE) || toks.back().t == T_LEFTBRACKET) && toks.back().t != T_RIGHTBRACKET)) {
i += ConsumeDigits(strbuf, &(exp[i]));
// Contains a dot: float
if (StrContains(strbuf, '.'))
AppendToken(T_FLOAT, strbuf);
else // Else integer
AppendToken(T_INTEGER, strbuf);
}
else
AppendToken(T_SUBTRACT, "-");
break;
case '*':
AppendToken(T_MULTIPLY, "*");
break;
case '/':
AppendToken(T_DIVIDE, "/");
break;
case '^':
AppendToken(T_POWER, "^");
break;
case '%':
AppendToken(T_MOD, "%");
break;
case '(':
AppendToken(T_LEFTBRACKET, "(");
break;
case ')':
AppendToken(T_RIGHTBRACKET, ")");
break;
case '{':
AppendToken(T_LEFTCURLY, "{");
break;
case '}':
AppendToken(T_RIGHTCURLY, "}");
break;
case '@':
AppendToken(T_AT, "@");
break;
case ',':
AppendToken(T_COMMA, ",");
break;
case '.':
AppendToken(T_DOT, ".");
break;
case '"':
i += AppendString(&(exp[i]), editorMode);
break;
case '\'':
i += AppendString(&(exp[i]), editorMode, true);
break;
case '=':
AppendToken(T_EQUAL, "=");
break;
case '<':
if (NextCh == '=') {
AppendToken(T_LESSEQUAL, "<=");
i++;
}
else if (NextCh == '>') {
AppendToken(T_NOTEQUAL, "<>");
i++;
}
else
AppendToken(T_LESS, "<");
break;
// Alternative not equal operator != <>
case '!':
if (NextCh == '=') {
AppendToken(T_NOTEQUAL, "!=");
i++;
}
else
NotifyError("Syntax error: '!'");
break;
case '&':
AppendToken(T_AND, "&");
break;
case '|':
AppendToken(T_OR, "|");
break;
case '>':
if (NextCh == '=') {
AppendToken(T_GREATEREQUAL, ">=");
i++;
}
else
AppendToken(T_GREATER, ">");
break;
case '?':
AppendToken(T_CONDITIONAL, "?");
break;
case ':':
AppendToken(T_COLON, ":");
break;
default:
// Parse numbers and idents
if (IsChAlphaNumeric(CurCh))
i += ConsumeAppendIdentifier(strbuf, &(exp[i]));
// Skip over whitespace
else if (IsWhitespace(CurCh)) {
// In editor mode add a T_WHITESPACE token
if (editorMode) {
Token t;
t.length = 0;
t.t = T_WHITESPACE;
while (IsWhitespace(exp[i])) {
t.str += exp[i];
i++;
}
// We want the next for loop iteration to see the next char
i--;
toks.push_back(t);
}
// Add to last token length
if (toks.size() > 0)
toks[toks.size() - 1].length++;
}
// Else unknown character
else {
string error = "Unknown character '";
error += CurCh;
error += "'";
throw runtime_error(error.c_str());
}
}//switch
}//for
// Only perform preprocessing when not in edittime mode
if (!editorMode)
PreProcessTokStream();
///////////////////////////
// Final step: parse to tree
// Determine if the overall expression is constant, collapsing constant parts along
// the way.
// Runtime only
#ifdef RUNTIME
// Make the tree
int step = 0;
ExpTree = DoTree(step);
isConstant = ExpTree->Constant();
// If constant, get the constant value.
if (isConstant) {
CollapseConstantTree(ExpTree);
ExpTree->Evaluate(&constantValue);
}
#endif
}
