////////////////////////////
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>
/// zastapienie ciagu tokenków zmienną i podpiecie nowego wyrazenia do zmiennej
/// </summary>
public void CorrectQueueExpression(
Expression Expression,
ParserSettings ParserSettings,
ExpressionGroup ExpressionGroup)
{
if (Expression == null)
{
return;
}
if (Expression.Tokens == null || Expression.Tokens.Count <= 0)
{
return;
}
for (var i = 0; i < Expression.Tokens.Count; i++)
{
ExpressionToken token = Expression.Tokens[i];
ExpressionToken token_next = i + 1 < Expression.Tokens.Count ? Expression.Tokens[i + 1] : null;
ExpressionToken token_prev = i - 1 >= 0 ? Expression.Tokens[i - 1] : null;
ExpressionTokens functionCallTokens = new ExpressionTokens(
GetNextTokensOnSameLevel(Expression.Tokens, i));
if (functionCallTokens.Count > 1)
{
// generowanie expressions dla wnętrz funkcji
IList <ExpressionTokens> functionParameters = SplitTokensIntoFunctionParameters(functionCallTokens).ToList();
foreach (ExpressionTokens functionParameter in functionParameters)
{
// generowanie expression z wyrażenia z parametru
if (functionParameter.Count > 1)
{
Expression functionExpression = new Expression();
functionExpression.Tokens = new ExpressionTokens(functionParameter);
functionExpression.IsOnpExecution = true;
ExpressionGroup.Expressions[functionExpression.ID] =
functionExpression;
new Tokenizer().PrepareExpressions(
functionExpression,
ParserSettings,
ExpressionGroup);
ExpressionToken functionParameterToken = new ExpressionToken(
functionExpression.ID.ToCharArray(),
TokenType.VARIABLE);
Int32 index = Expression.Tokens.
RemoveSequence(functionParameter);
Expression.Tokens.Insert(
index,
functionParameterToken);
i = index;
}
// gdy pojedyncze wyrażenie w fukncji
else
{
Int32 index = Expression.Tokens.
IndexOfSequence(functionParameter);
i = index;
}
}
// dla operatora @ ustalenie liczby parametrów
if (token_prev != null &&
token_prev.TokenType == TokenType.OPERATOR &&
(OnpOnpTokenHelper.IsFunctionOperatorToken(token_prev)))
{
token_prev.TokenData = new OnpTokenData();
token_prev.TokenData.FunctionParametersCount = functionParameters.Count;
}
}
else
{
// zamiana typu zmiennej na property_name jeśli nie jest to pierwsza zmienna
if (i > 0 && (token.TokenType == TokenType.VARIABLE || token.TokenType == TokenType.VALUE))
{
if (token_next == null || !OnpOnpTokenHelper.IsFunctionOperatorToken(token_next))
{
token.TokenType = TokenType.PROPERTY_NAME;
}
}
// usunięcie operatorów typu 'get property' ('.')
/*else if (OnpOnpTokenHelper.IsPropertyOperatorToken(token) )
* {
* queueTokens.RemoveAt(i);
* i--;
* }*/
}
}
}
/// <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;
}
private static void ValidateTokens(
ExpressionTokens tokens)
{
Int32 equalOperators = 0;
Int32 beginBrackets = 0;
Int32 endBrackets = 0;
for (int i = 0; i < tokens.Count; i++)
{
ExpressionToken prevToken = i > 0 ? tokens[i - 1] : null;
ExpressionToken currentToken = tokens[i];
ExpressionToken nextToken = i < tokens.Count - 1 ? tokens[i + 1] : null;
Boolean isStringOrNumber =
/* currentToken.TokenType == TokenType.FUNCTION_CALL ||*/
currentToken.TokenType == TokenType.VARIABLE ||
currentToken.TokenType == TokenType.VALUE ||
currentToken.TokenType == TokenType.PROPERTY_NAME;
Boolean isOperator =
currentToken.TokenType == TokenType.OPERATOR;
// przecinki moga wystepowac tylko w nawiasach i przy wolaniu funkcji
if (currentToken.TokenType == TokenType.SEPARATOR)
{
Boolean functionCallFound = false;
Int32 innerBrackets = 0;
for (var j = i - 1; j >= 0; j--)
{
ExpressionToken token = tokens[j];
if (token.TokenType == TokenType.BRACKET_END)
{
innerBrackets++;
}
else if (token.TokenType == TokenType.BRACKET_BEGIN)
{
innerBrackets--;
}
else if (token.TokenType == TokenType.OPERATOR &&
OnpOnpTokenHelper.IsFunctionOperatorToken(token))
{
if (innerBrackets == -1)
{
functionCallFound = true;
break;
}
}
}
if (!functionCallFound)
{
throw new PainIncorrectExpressionFormatException("Invalid function call");
}
}
if (currentToken.TokenType == TokenType.EQUAL_OPERATOR)
{
equalOperators++;
}
if (nextToken != null)
{
if (isOperator &&
(nextToken.TokenType == TokenType.OPERATOR ||
nextToken.TokenType == TokenType.BRACKET_END))
{
throw new PainIncorrectExpressionFormatException("Incorrect symbol '" + nextToken.TokenName + "' after operator '" + currentToken.TokenName + "'");
}
else if (currentToken.TokenType == TokenType.BRACKET_BEGIN &&
!OnpOnpTokenHelper.IsFunctionOperatorToken(prevToken) &&
(nextToken.TokenType == TokenType.OPERATOR ||
nextToken.TokenType == TokenType.BRACKET_END ||
nextToken.TokenType == TokenType.EQUAL_OPERATOR))
{
throw new PainIncorrectExpressionFormatException("Incorrect symbol '" + nextToken.TokenName + "' after operator '('");
}
else if (
currentToken.TokenType == TokenType.BRACKET_END &&
nextToken.TokenType != TokenType.OPERATOR &&
nextToken.TokenType != TokenType.EQUAL_OPERATOR &&
nextToken.TokenType != TokenType.BRACKET_END &&
nextToken.TokenType != TokenType.SEPARATOR)
{
throw new PainIncorrectExpressionFormatException("Incorrect symbol '" + nextToken.TokenName + "' after operator ')'");
}
}
if (currentToken.TokenType == TokenType.BRACKET_BEGIN)
{
beginBrackets++;
}
else if (currentToken.TokenType == TokenType.BRACKET_END)
{
endBrackets++;
}
}
if (beginBrackets != endBrackets)
{
throw new PainIncorrectExpressionFormatException("Number of opening brackets is not equal with number of ending brackets");
}
}
