////////////////////////////
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();
}
}
}
/// <summary>
/// Odszukanie ciągów QUEUE w wyrażeniu
/// </summary>
public void PrepareQueueExpressions(
IList <ExpressionToken> Tokens,
ParserSettings ParserSettings,
ExpressionGroup ExpressionGroup)
{
ExpressionTokens outTokens = new ExpressionTokens();
ExpressionTokens queueTokens = null;
Boolean queueStarted = false;
Int32 startIndex = -1;
Int32 endIndex = -1;
for (var i = 0; i < Tokens.Count; i++)
{
ExpressionToken token = Tokens[i];
// rozpoczecie sekwencji queue
if (token != null &&
queueStarted == false &&
(OnpOnpTokenHelper.IsPropertyOperatorToken(token) || OnpOnpTokenHelper.IsFunctionOperatorToken(token)))
{
ExpressionTokens sequence = new ExpressionTokens(
GetNextTokensOnSameLevel(Tokens, i));
ExpressionTokens prevSequence = new ExpressionTokens(
GetPrevTokensOnSameLevel(Tokens, i - 1));
if (queueTokens == null)
{
queueTokens = new ExpressionTokens();
}
if (prevSequence == null)
{
throw new FormatException();
}
queueTokens.AddRange(prevSequence);
queueTokens.AddRange(sequence);
queueStarted = true;
startIndex = i - prevSequence.Count;
i += sequence.Count - 1;
}
// zakończenie sekwencji queue
else if (
token != null &&
queueStarted == true &&
(
token.TokenType == TokenType.BRACKET_END ||
token.TokenType == TokenType.OPERATOR &&
!OnpOnpTokenHelper.IsPropertyOperatorToken(token) &&
!OnpOnpTokenHelper.IsFunctionOperatorToken(token)
))
{
endIndex = i - 1;
// zastapienie ciagu tokenków zmienną i podpiecie nowego wyrazenia do zmiennej
if (queueTokens != null && queueTokens.Count > 0)
{
ExpressionToken newToken = CreateQueueExpression(
queueTokens,
ParserSettings,
ExpressionGroup);
for (var j = endIndex; j >= startIndex; j--)
{
Tokens.RemoveAt(j);
i--;
}
Tokens.Insert(startIndex, newToken);
}
queueTokens = null;
endIndex = -1;
startIndex = -1;
queueStarted = false;
}
// kontynuacja sekwencji queue
else if (queueStarted == true)
{
ExpressionTokens sequence = new ExpressionTokens(
GetNextTokensOnSameLevel(Tokens, i));
queueTokens.AddRange(
sequence);
i += sequence.Count - 1;
}
}
// zastapienie ciagu tokenków zmienną i podpiecie nowego wyrazenia do zmiennej
if (queueTokens != null && queueTokens.Count > 0)
{
endIndex = Tokens.Count - 1;
ExpressionToken newToken = CreateQueueExpression(
queueTokens,
ParserSettings,
ExpressionGroup);
for (var j = endIndex; j >= startIndex; j--)
{
Tokens.RemoveAt(j);
}
Tokens.Insert(startIndex, newToken);
}
queueTokens = null;
endIndex = -1;
startIndex = -1;
}