private static void ConvertIndexersToFunctions(ExpressionTokens Tokens)
{
for (var i = 0; i < Tokens.Count; i++)
{
ExpressionToken token = Tokens[i];
if (token.TokenType == TokenType.INDEXER_BEGIN)
{
token.Set(".", false);
token.TokenType = TokenType.OPERATOR;
Tokens.Insert(
i + 1,
new ExpressionToken(ExtenderCollectionGetter.NameChars, TokenType.VARIABLE));
Tokens.Insert(
i + 2,
new ExpressionToken("@", TokenType.OPERATOR));
Tokens.Insert(
i + 3,
new ExpressionToken("(", TokenType.BRACKET_BEGIN));
}
else if (token.TokenType == TokenType.INDEXER_END)
{
token.Set(")", false);
token.TokenType = TokenType.BRACKET_END;
}
}
}
////////////////////////////
private void CorrectSetExpression(
Expression SetExpression,
String ValueExpressionID,
ParserSettings ParserSettings,
ExpressionGroup ExpressionGroup)
{
if (SetExpression.Tokens.Count == 0)
{
return;
}
// jeśli tylko jeden symbol (podstawienie do zmiennej)
else if (SetExpression.Tokens.Count == 1)
{
ExpressionToken firstToken = SetExpression.Tokens[0];
if (firstToken.TokenType != TokenType.VARIABLE)
{
throw new PainIncorrectExpressionFormatException("Incorrect setting value to type " + firstToken.TokenType + "");
}
if (firstToken.TokenName.Length == 0 || Char.IsDigit(firstToken.TokenName[0]))
{
throw new PainIncorrectExpressionFormatException("Incorrect name of token '" + firstToken.TokenName + "'");
}
SetExpression.Tokens.Clear();
SetExpression.Tokens.AddRange(
new[] {
new ExpressionToken(MethodSetValue.Name.ToUpper(), TokenType.VARIABLE),
new ExpressionToken(OperatorTypeHelper.op_methodcall, TokenType.OPERATOR),
new ExpressionToken('(', TokenType.BRACKET_BEGIN),
new ExpressionToken("'" + firstToken.TokenName + "'", TokenType.VALUE),
new ExpressionToken(',', TokenType.SEPARATOR),
new ExpressionToken(ValueExpressionID, TokenType.VARIABLE),
new ExpressionToken(')', TokenType.BRACKET_END)
});
}
// jeśli przypisanie wyniku do elementu listy lub dictionary
else
{
Int32 lastIndex = SetExpression.Tokens.Count - 1;
ExpressionTokens sequence2 = new ExpressionTokens(
new TokenizerQueue().
GetPrevTokensOnSameLevel(
SetExpression.Tokens,
lastIndex));
ExpressionTokens sequence1 = new ExpressionTokens(
new TokenizerQueue().
GetPrevTokensOnSameLevel(
SetExpression.Tokens,
lastIndex - sequence2.Count));
ExpressionTokens sequence0 = new ExpressionTokens(
new TokenizerQueue().
GetPrevTokensOnSameLevel(
SetExpression.Tokens,
lastIndex - sequence2.Count - sequence1.Count));
// a.get@(b).c = d ========> a.get@(b).set2@('c',d)
if (sequence2.Count == 1 &&
sequence1.Count == 1 &&
OnpOnpTokenHelper.IsPropertyOperatorToken(sequence1[0]))
{
ExpressionToken propertyOperatorToken = sequence1[0];
ExpressionToken propertyNameToken = sequence2[0];
SetExpression.Tokens.Remove(propertyNameToken);
SetExpression.Tokens.AddRange(
new[] {
new ExpressionToken(ExtenderSetValue.Name.ToUpper().ToCharArray(), TokenType.VARIABLE),
new ExpressionToken(OperatorTypeHelper.op_methodcall, TokenType.OPERATOR),
new ExpressionToken('(', TokenType.BRACKET_BEGIN),
new ExpressionToken("'" + propertyNameToken.TokenName + "'", TokenType.VALUE),
new ExpressionToken(',', TokenType.SEPARATOR),
new ExpressionToken(ValueExpressionID, TokenType.VARIABLE),
new ExpressionToken(')', TokenType.BRACKET_END)
});
}
// a.get@(b).get@(d) = e ========> a.get@(b).set2@(d,e)
else if (
sequence2.Count > 1 &&
sequence1.Count == 1 &&
OnpOnpTokenHelper.IsFunctionOperatorToken(sequence1[0]) &&
sequence0.Count == 1 &&
(sequence0[0].TokenType == TokenType.PROPERTY_NAME || sequence0[0].TokenType == TokenType.VARIABLE))
{
ExpressionToken functionNameToken = sequence0[0];
ExpressionToken functionOperatorToken = sequence1[0];
ExpressionTokens functionCallToken = sequence2;
functionNameToken.Set(
ExtenderCollectionSetter.NameChars, false);
Int32 bracketBeginIndex = SetExpression.
Tokens.
IndexOf(functionCallToken[0]);
SetExpression.Tokens.Insert(
bracketBeginIndex + 1,
new ExpressionToken(ValueExpressionID, TokenType.VARIABLE));
SetExpression.Tokens.Insert(
bracketBeginIndex + 2,
new ExpressionToken(',', TokenType.SEPARATOR));
}
else
{
throw new PainIncorrectExpressionFormatException();
}
}
}
private static void OptimizeTokens(
ExpressionTokens tokens)
{
// usuwanie pustych nawiasów
/*for (int i = 0; i < tokens.Count - 1; i++)
* {
* ExpressionToken currentToken = tokens[i];
* ExpressionToken nextToken = tokens[i + 1];
*
* // usuwanie pustych nawiasów
* if (currentToken.TokenType == TokenType.BRACKET_BEGIN &&
* nextToken.TokenType == TokenType.BRACKET_END)
* {
* tokens.Insert(i + 1, new ExpressionToken(OperatorTypeHelper.number_zero, TokenType.VALUE));
* i--;
* }
* }*/
// zamiana dwóch minusów na plus
for (int i = 0; i < tokens.Count - 1; i++)
{
ExpressionToken currentToken = tokens[i];
ExpressionToken nextToken = tokens[i + 1];
Boolean isMinus =
currentToken.TokenType == TokenType.OPERATOR &&
StringHelper.StartsWith(currentToken.TokenChars, DynLanuageSymbols.MinusChars, false);
Boolean isNextMinus =
nextToken.TokenType == TokenType.OPERATOR &&
StringHelper.StartsWith(nextToken.TokenChars, DynLanuageSymbols.MinusChars, false);
// zamiana dwóch minusów na plus
if (isMinus && isNextMinus)
{
currentToken.Set(DynLanuageSymbols.PlusChars);
tokens.RemoveAt(i + 1);
i--;
}
}
// zamiana dwóch plusów na jeden plus
/*for (int i = 0; i < tokens.Count - 1; i++)
* {
* ExpressionToken currentToken = tokens[i];
* ExpressionToken nextToken = tokens[i + 1];
*
* Boolean isPlus =
* currentToken.TokenType == TokenType.OPERATOR &&
* StringHelper.StartsWith(currentToken.TokenChars, DynLanuageSymbols.PlusChars, false);
*
* Boolean isNextPlus =
* nextToken.TokenType == TokenType.OPERATOR &&
* StringHelper.StartsWith(nextToken.TokenChars, DynLanuageSymbols.PlusChars, false);
*
* // zamiana dwóch plusów na jeden plus
* if (isPlus && isNextPlus)
* {
* tokens.RemoveAt(i + 1);
* i--;
* }
* }*/
}
