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 ExpressionTokens GetSetTokens(IList <ExpressionToken> Tokens)
{
ExpressionTokens result = null;
if (Tokens.Count >= 2)
{
if (Tokens.Any(t => t.TokenType == TokenType.EQUAL_OPERATOR))
{
for (var i = 0; i < Tokens.Count; i++)
{
ExpressionToken token = Tokens[i];
if (token.TokenType == TokenType.EQUAL_OPERATOR)
{
break;
}
if (result == null)
{
result = new ExpressionTokens();
}
result.Add(token);
}
}
}
return(result);
}
/// <summary>
/// zastapienie ciagu tokenków zmienną i podpiecie nowego wyrazenia do zmiennej
/// </summary>
public ExpressionToken CreateQueueExpression(
ExpressionTokens queueTokens,
ParserSettings ParserSettings,
ExpressionGroup ExpressionGroup)
{
if (queueTokens != null && queueTokens.Count > 0)
{
Expression newExpression = new Expression();
newExpression.Tokens = queueTokens;
newExpression.IsOnpExecution = false;
ExpressionGroup.Expressions[newExpression.ID] =
newExpression;
CorrectQueueExpression(
newExpression,
ParserSettings,
ExpressionGroup);
return(new ExpressionToken(
newExpression.ID.ToCharArray(),
TokenType.VARIABLE));
}
return(null);
}
public static ExpressionTokens GetOptimizedTokens(
IList <Char> expressionChars,
ParserSettings ParserSettings)
{
if (ParserSettings == null)
{
ParserSettings = new ParserSettings();
}
ExpressionTokens tokens = new ExpressionTokens(
TokenGetter.GetTokens(expressionChars));
ConvertIndexersToFunctions(tokens);
AddFunctionCallOperator(tokens);
ConvertMinusOperatorToMinusOne(tokens);
// RemoveOperatorsOnEnd(tokens);
if (ParserSettings.Optimize)
{
OptimizeTokens(tokens);
}
if (ParserSettings.Validate)
{
ValidateTokens(tokens);
}
//CorrectFunctionCallTokenInfo(tokens);
return(tokens);
}
////////////////////////////
/// <summary>
/// Zwraca przygotowane wyrażenie
/// </summary>
public void PrepareMainExpression(
String ExpressionId,
IList <Char> ExpressionChars,
ParserSettings ParserSettings,
ExpressionGroup ExpressionGroup)
{
Expression onpExpression = new Expression(ExpressionId);
onpExpression.Tokens = TokenGetter.GetOptimizedTokens(ExpressionChars, ParserSettings);
ExpressionGroup.Expressions[ExpressionId] = onpExpression;
// zamiania znaków równości na wołanie funkcji
List <ExpressionTokens> resultTokens = new List <ExpressionTokens>();
while (true)
{
ExpressionTokens setTokens = TakeSetTokens(
onpExpression.Tokens);
if (setTokens == null)
{
break;
}
resultTokens.Insert(0, setTokens);
}
Expression currentExpression = onpExpression;
foreach (ExpressionTokens resultToken in resultTokens)
{
Expression setExpression = new Expression();
setExpression.IsOnpExecution = false;
setExpression.Tokens = resultToken;
ExpressionGroup.Expressions[setExpression.ID] = setExpression;
PrepareExpressions(
setExpression,
ParserSettings,
ExpressionGroup);
CorrectSetExpression(
setExpression,
currentExpression.ID,
ParserSettings,
ExpressionGroup);
currentExpression = setExpression;
}
ExpressionGroup.MainExpression = currentExpression;
PrepareExpressions(
onpExpression,
ParserSettings,
ExpressionGroup);
}
public void Add(OptimizerResult resultToAdd)
{
foreach (var variableToken in resultToAdd.VariableTokens)
{
AddVariable(variableToken.Key, variableToken.Value);
}
ExpressionTokens.AddRange(resultToAdd.ExpressionTokens);
}
////////////////////////////////////////////////////
public IEnumerable <ExpressionTokens> SplitTokensIntoFunctionParameters(
IList <ExpressionToken> Tokens)
{
if (Tokens.Count < 2 ||
Tokens[0].TokenType != TokenType.BRACKET_BEGIN ||
Tokens[Tokens.Count - 1].TokenType != TokenType.BRACKET_END)
{
yield return(new ExpressionTokens(Tokens));
yield break;
}
Int32 startIndex = 1;
Int32 maxIndex = Tokens.Count - 1;
Int32 bracketCount = 0;
ExpressionTokens result = new ExpressionTokens();
for (var i = startIndex; i < maxIndex; i++)
{
ExpressionToken token = Tokens[i];
if (token.TokenType == TokenType.BRACKET_BEGIN)
{
bracketCount++;
}
else if (bracketCount > 0 && token.TokenType == TokenType.BRACKET_END)
{
bracketCount--;
}
if (bracketCount == 0 &&
token.TokenType == TokenType.SEPARATOR)
{
if (result.Count > 0)
{
yield return(result);
result = new ExpressionTokens();
}
}
else
{
result.Add(token);
}
}
if (result.Count > 0)
{
yield return(result);
}
}
/*private static void CheckOperatorsOnEnd(
* ExpressionTokens tokens)
* {
* // usunięcie operatorów na końcu
* for (int i = tokens.Count - 1; i >= 0; i--)
* {
* ExpressionToken currentToken = tokens[i];
* if (currentToken.TokenType == TokenType.OPERATOR)
* {
* tokens.RemoveAt(i);
* }
* else
* {
* break;
* }
* }
* }*/
private static void RemoveOperatorsOnEnd(
ExpressionTokens tokens)
{
// usunięcie operatorów na końcu
for (int i = tokens.Count - 1; i >= 0; i--)
{
ExpressionToken currentToken = tokens[i];
if (currentToken.TokenType == TokenType.OPERATOR)
{
tokens.RemoveAt(i);
}
else
{
break;
}
}
}
//////////////////////////////////////////////////////////////////
private static void ConvertMinusOperatorToMinusOne(ExpressionTokens Tokens)
{
for (var i = 0; i < Tokens.Count; i++)
{
ExpressionToken token = Tokens[i];
ExpressionToken nextToken = null;
ExpressionToken prevToken = null;
nextToken = (i + 1 < Tokens.Count ? Tokens[i + 1] : null);
prevToken = (i - 1 >= 0 ? Tokens[i - 1] : null);
// zamiana minusa na -1
if (token.TokenType == TokenType.OPERATOR)
{
if (StringHelper.StartsWith(token.TokenChars, OperatorTypeHelper.op_minus, false))
{
//if (!(nextToken.TokenType == TokenType.VALUE && StringHelper.IsDateTime(nextToken.TokenChars)))
{
Tokens.RemoveAt(i);
Int32 index = i;
if (prevToken != null && (
/*prevToken.TokenType == TokenType.FUNCTION_CALL ||*/
prevToken.TokenType == TokenType.BRACKET_END ||
prevToken.TokenType == TokenType.VALUE ||
prevToken.TokenType == TokenType.PROPERTY_NAME ||
prevToken.TokenType == TokenType.VARIABLE))
{
ExpressionToken operator1 = new ExpressionToken(OperatorTypeHelper.op_plus, TokenType.OPERATOR);
Tokens.Insert(index++, operator1);
}
ExpressionToken value1 = new ExpressionToken(OperatorTypeHelper.number_minus_one, TokenType.VALUE);
Tokens.Insert(index++, value1);
if (nextToken != null)
{
ExpressionToken operator2 = new ExpressionToken(OperatorTypeHelper.op_multiply, TokenType.OPERATOR);
Tokens.Insert(index++, operator2);
}
}
}
}
}
}
private static ExpressionTokens GetParameterTokens(
ExpressionTokens tokenParameters)
{
ExpressionTokens parameterTokens = new ExpressionTokens();
foreach (ExpressionToken token in tokenParameters)
{
if (token.TokenType == TokenType.VARIABLE)
{
parameterTokens.Add(token);
}
else if (token.TokenType == TokenType.VALUE)
{
parameterTokens.Add(token);
}
}
return(parameterTokens);
}
public override void ProcessExpression(ExpressionTokens expressionTokens)
{
List <Expression> entityTokens =
(from token in expressionTokens.Tokens
where token.ExpressionType == ExpressionType.Entity
select token)
.ToList();
if (entityTokens.Count() < 2)
{
this.Result = "Must specify at least two items.";
foreach (Expression token in entityTokens)
{
Console.WriteLine("Token: " + token.Result);
}
return;
}
EntityExpression origin = (EntityExpression)entityTokens[0];
EntityExpression destination = (EntityExpression)entityTokens[1];
Container originContainer =
origin.ParentContainer.GetComponent <Container>();
Container destinationContainer =
destination.Entity.GetComponent <Container>();
if (originContainer != null &&
destinationContainer != null)
{
// TODO: Bug - Not always removing from the right container.
originContainer.RemoveEntity(origin.Entity);
destinationContainer.AddEntity(origin.Entity);
this.Result =
"Moved " + origin.Entity.GetName() +
" to " + destination.Entity.GetName() + ".";
}
else
{
this.Result = "Cannot move item to something that isn't a container.";
}
}
private ExpressionTokens TakeSetTokens(IList <ExpressionToken> Tokens, Boolean RemoveTakenTokens = true)
{
ExpressionTokens result = null;
if (Tokens.Count >= 2)
{
if (Tokens.Any(t => t.TokenType == TokenType.EQUAL_OPERATOR))
{
for (var i = 0; i < Tokens.Count; i++)
{
ExpressionToken token = Tokens[i];
if (token.TokenType == TokenType.EQUAL_OPERATOR)
{
if (RemoveTakenTokens)
{
Tokens.RemoveAt(i);
}
break;
}
if (result == null)
{
result = new ExpressionTokens();
}
result.Add(token.Clone());
if (RemoveTakenTokens)
{
Tokens.RemoveAt(i);
i--;
}
}
}
}
return(result);
}
public override void ProcessExpression(ExpressionTokens expressionTokens)
{
IList <EntityModel> inventory;
Expression nextToken = expressionTokens.GetRightToken();
if (nextToken != null &&
nextToken.ExpressionType == ExpressionType.Parameter &&
nextToken.Result.Equals("all"))
{
inventory = new EntityModel(expressionTokens.InvokingEntity)
.SaturateContainerDetails(recurse: true)
.Entities;
}
else
{
inventory = new EntityModel(expressionTokens.InvokingEntity)
.SaturateContainerDetails(recurse: false)
.Entities;
}
this.Interpretted = true;
this.Result = inventory;
}
private static void AddFunctionCallOperator(ExpressionTokens Tokens)
{
for (var i = 0; i < Tokens.Count; i++)
{
ExpressionToken token = Tokens[i];
ExpressionToken nextToken = null;
ExpressionToken prevToken = null;
nextToken = (i + 1 < Tokens.Count ? Tokens[i + 1] : null);
prevToken = (i - 1 >= 0 ? Tokens[i - 1] : null);
// zamiana minusa na -1
if (token.TokenType == TokenType.BRACKET_BEGIN &&
prevToken != null &&
prevToken.TokenType != TokenType.SEPARATOR &&
prevToken.TokenType != TokenType.OPERATOR &&
prevToken.TokenType != TokenType.EQUAL_OPERATOR &&
prevToken.TokenType != TokenType.BRACKET_BEGIN)
{
ExpressionToken value1 = new ExpressionToken(OperatorTypeHelper.op_methodcall, TokenType.OPERATOR);
Tokens.Insert(i, value1);
}
}
}
/// <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 = Linq2.ToList(SplitTokensIntoFunctionParameters(functionCallTokens));
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>
/// Processes the expression associated with this object.
/// </summary>
public virtual void ProcessExpression(ExpressionTokens expressionTokens)
{
}
//////////////////////////////////////////////////////////////////
private static void ConvertMinusOperatorToMinusOne(ExpressionTokens Tokens)
{
for (var i = 0; i < Tokens.Count; i++)
{
ExpressionToken token = Tokens[i];
ExpressionToken nextToken = null;
ExpressionToken prevToken = null;
// nie potrzebne poniewaz usuwane sa biale znaki
/*
* for (var j = i + 1; j < Tokens.Count; j++)
* if (Tokens[j].TokenType != TokenType.WHITESPACE)
* {
* nextToken = Tokens[j];
* break;
* }
*
* for (var j = i - 1; j >= 0; j--)
* if (Tokens[j].TokenType != TokenType.WHITESPACE)
* {
* prevToken = Tokens[j];
* break;
* }
*/
nextToken = (i + 1 < Tokens.Count ? Tokens[i + 1] : null);
prevToken = (i - 1 >= 0 ? Tokens[i - 1] : null);
// zamiana minusa na -1
if (token.TokenType == TokenType.OPERATOR)
{
if (StringHelper.StrEquals(token.TokenChars, OperatorTypeHelper.op_minus, false))
{
//if (!(nextToken.TokenType == TokenType.VALUE && StringHelper.IsDateTime(nextToken.TokenChars)))
{
Tokens.RemoveAt(i);
Int32 index = i;
if (prevToken != null && (
/*prevToken.TokenType == TokenType.FUNCTION_CALL ||*/
prevToken.TokenType == TokenType.BRACKET_END ||
prevToken.TokenType == TokenType.VALUE ||
prevToken.TokenType == TokenType.PROPERTY_NAME ||
prevToken.TokenType == TokenType.VARIABLE))
{
ExpressionToken operator1 = new ExpressionToken(OperatorTypeHelper.op_plus, TokenType.OPERATOR);
Tokens.Insert(index++, operator1);
}
ExpressionToken value1 = new ExpressionToken(OperatorTypeHelper.number_minus_one, TokenType.VALUE);
Tokens.Insert(index++, value1);
if (nextToken != null)
{
ExpressionToken operator2 = new ExpressionToken(OperatorTypeHelper.op_multiply, TokenType.OPERATOR);
Tokens.Insert(index++, operator2);
}
}
}
}
}
}
public static Boolean EvaluateQueue(
DynContext DynLanContext)
{
ExpressionState expState = DynLanContext.CurrentExpressionState;
ExpressionContext expContext = DynLanContext.CurrentExpressionContext;
// policzenie nastepnego parametru
if (expState.AreParametersCalculating)
{
expState.ParameterIndex++;
if (expState.ParameterIndex < expState.ParameterTokens.Count)
{
Boolean result = false;
ExpressionToken parameterToken = expState.ParameterTokens[expState.ParameterIndex];
if (parameterToken.TokenType == TokenType.VARIABLE)
{
result = ObjectValueGetter.EvaluateValue(
parameterToken.TokenName,
DynLanContext);
}
else if (parameterToken.TokenType == TokenType.VALUE)
{
ExpressionValue operationValue = StringHelper.
GetValueFromText(parameterToken.TokenChars);
Object value = (
operationValue == null ? null : operationValue.Value);
expState.Parameters.Add(value);
}
else
{
throw new DynLanIncorrectExpressionFormatException();
}
return(result);
}
}
// czy zakończyć i zapisać wynik
if (expState.TokenIndex >= expState.Expression.Tokens.Count)
{
Object finResult = null;
if (expState.ValueStack.Count > 0)
{
finResult = MyCollectionsExtenders.Pop(expState.ValueStack);
}
expState.ValueStack.Clear();
expState.Finished = true;
expState.Result = InternalTypeConverter.ToOuter(finResult);
MyCollectionsExtenders.Pop(expContext.Stack);
if (expContext.Current != null)
{
expContext.Current.PushValue(InternalTypeConverter.ToOuter(finResult));
return(false);
}
else
{
expContext.Result = InternalTypeConverter.ToOuter(finResult);
expContext.IsFinished = true;
return(true);
}
}
Boolean isFirstToken = expState.TokenIndex == 0;
ExpressionToken token = expState.
Expression.
Tokens[expState.TokenIndex];
ExpressionTokens sequence = new ExpressionTokens(
new TokenizerQueue().
GetNextTokensOnSameLevel(expState.Expression.Tokens, expState.TokenIndex));
Int32 originalSequenceCount = sequence.Count;
sequence.RemoveBrackets();
// wykonanie następnej operacji
if (token.TokenType == TokenType.BRACKET_BEGIN)
{
IList <ExpressionToken> prevSequenceTokens = new TokenizerQueue().
GetPrevTokensOnSameLevel(expState.Expression.Tokens, expState.TokenIndex - 1);
ExpressionTokens prev_sequence = prevSequenceTokens == null ?
null : new ExpressionTokens(prevSequenceTokens);
// jeśli poprzedni operator to @
if (
prev_sequence != null && prev_sequence.Count == 1 &&
OnpOnpTokenHelper.IsFunctionOperatorToken(prev_sequence[0]))
{
Boolean result = false;
if (sequence.Count == 0 || expState.AreParametersCalculated)
{
Object obj = expState.ValueStack.Count == 1 ?
new EmptyObject() :
MyCollectionsExtenders.Peek(expState.ValueStack, 1);
Object methodObject = MyCollectionsExtenders.
Peek(expState.ValueStack, 0);
result = EvaluatorForMethods.EvaluateMethod(
obj,
methodObject,
expState.Parameters,
DynLanContext);
expState.CleanParametersState();
expState.TokenIndex += originalSequenceCount;
}
else
{
expState.ParameterTokens = GetParameterTokens(sequence);
expState.ParameterIndex = -1;
expState.Parameters = new List <Object>();
result = false;
}
return(result);
}
// jeśli poprzedni operator to .
else if (
prev_sequence != null && prev_sequence.Count == 1 &&
OnpOnpTokenHelper.IsPropertyOperatorToken(prev_sequence[0]))
{
throw new DynLanIncorrectExpressionFormatException();
}
// jeśli brak poprzedniego operatora
else if (
prev_sequence == null &&
sequence.Count == 1)
{
Boolean result = false;
if (sequence[0].TokenType == TokenType.VARIABLE)
{
result = ObjectValueGetter.EvaluateValue(
sequence[0].TokenName,
DynLanContext);
}
else if (sequence[0].TokenType == TokenType.VALUE)
{
ExpressionValue operationValue = StringHelper.
GetValueFromText(sequence[0].TokenChars);
Object value = (
operationValue == null ? null : operationValue.Value);
expState.PushValue(value);
}
else
{
throw new DynLanIncorrectExpressionFormatException();
}
expState.TokenIndex += originalSequenceCount; // -1;
return(result);
}
else
{
throw new DynLanInvalidExpressionException("Incorrect expression " + expState.Expression.Tokens.JoinToString(expState.TokenIndex) + "!");
}
}
else if (token.TokenType == TokenType.VALUE)
{
ExpressionValue operationValue = StringHelper.
GetValueFromText(token.TokenChars);
Object value = (
operationValue == null ? null : operationValue.Value);
if (isFirstToken)
{
expState.PushValue(value);
}
else
{
Object prevValue = MyCollectionsExtenders.Peek(expState.ValueStack);
prevValue = InternalTypeConverter.
ToOuter(prevValue);
Object method = ObjectValueGetter.GetValueFromObject(
prevValue,
UniConvert.ToString(value));
expState.PushValue(method);
}
expState.TokenIndex += originalSequenceCount; // -1
}
else if (token.TokenType == TokenType.PROPERTY_NAME)
{
if (isFirstToken)
{
throw new DynLanIncorrectExpressionFormatException();
}
else
{
Object prevValue = MyCollectionsExtenders.Peek(expState.ValueStack);
prevValue = InternalTypeConverter.
ToOuter(prevValue);
Object value = ObjectValueGetter.GetValueFromObject(
prevValue,
token.TokenName);
expState.PushValue(value);
}
expState.TokenIndex += originalSequenceCount; // -1
}
else if (token.TokenType == TokenType.VARIABLE)
{
Boolean result = false;
ExpressionToken next_token = expState.TokenIndex + 1 < expState.Expression.Tokens.Count ?
expState.Expression.Tokens[expState.TokenIndex + 1] :
null;
Object prevValue = null;
if (isFirstToken)
{
prevValue = new EmptyObject();
/*result = ObjectValueGetter.EvaluateValueOrMethod(
* new EMPTY_OBJECT(),
* sequence[0].TokenName,
* -1,
* DynLanContext);*/
}
else
{
prevValue = (
expState.ValueStack.Count == 0 ?
null :
MyCollectionsExtenders.Peek(expState.ValueStack));
}
prevValue = InternalTypeConverter.
ToOuter(prevValue);
Int32 paramCount = -1;
// jeśli następny operator to operator wołania funkcji @ to pobieramy z niego liczbę parametrów dla funkcji
if (OnpOnpTokenHelper.IsFunctionOperatorToken(next_token) &&
next_token.TokenData != null &&
next_token.TokenData.FunctionParametersCount != null)
{
paramCount = next_token.TokenData.FunctionParametersCount.Value;
}
else
{
paramCount = -1;
}
result = ObjectValueGetter.EvaluateValueOrMethod(
prevValue,
sequence[0].TokenName,
paramCount,
DynLanContext);
if (MyCollectionsExtenders.Peek(DynLanContext.CurrentExpressionState.ValueStack) == null)
{
ExpressionToken next_next_token = expState.TokenIndex + 2 < expState.Expression.Tokens.Count ?
expState.Expression.Tokens[expState.TokenIndex + 2] :
null;
if (next_token.TokenType == TokenType.OPERATOR &&
OnpOnpTokenHelper.IsPropertyOperatorToken(next_token) &&
next_next_token != null)
{
}
else
{
next_next_token = null;
}
if (paramCount < 0)
{
if (next_next_token != null)
{
ExpressionToken next_next_next_next_next_token = expState.TokenIndex + 5 < expState.Expression.Tokens.Count ?
expState.Expression.Tokens[expState.TokenIndex + 5] :
null;
if (next_next_token.TokenName == "__EXT_SET" && next_next_next_next_next_token != null)
{
throw new DynLanMethodNotFoundException("Cannot find property " + next_next_next_next_next_token.TokenName + " in undefined object '" + sequence[0].TokenName + "'");
}
else
{
throw new DynLanMethodNotFoundException("Cannot call method '" + next_next_token.TokenName + "' in undefined object '" + sequence[0].TokenName + "'");
}
}
else
{
throw new DynLanMethodNotFoundException("Undefined object '" + sequence[0].TokenName + "'");
}
}
else
{
throw new DynLanMethodNotFoundException("Undefined method '" + sequence[0].TokenName + "' " + (prevValue == null ? "in undefined object" : ("in object of type " + prevValue.GetType().Name)));
}
}
expState.TokenIndex += originalSequenceCount; // -1
return(result);
}
else if (token.TokenType == TokenType.OPERATOR)
{
if (!OnpOnpTokenHelper.IsFunctionOperatorToken(token) &&
!OnpOnpTokenHelper.IsPropertyOperatorToken(token))
{
throw new DynLanIncorrectExpressionFormatException();
}
expState.TokenIndex += originalSequenceCount; // -1
}
if (MyCollectionsExtenders.Peek(expState.ValueStack) == null)
{
return(false);
}
return(false);
}
public override void ProcessExpression(ExpressionTokens expressionTokens)
{
}
////////////////////////////
/// <summary>
/// Zwraca przygotowane wyrażenie
/// </summary>
public void PrepareMainExpression(
String ExpressionId,
IList <Char> ExpressionChars,
ParserSettings ParserSettings,
ExpressionGroup ExpressionGroup)
{
try
{
Expression onpExpression = new Expression(ExpressionId);
onpExpression.Tokens = TokenGetter.GetOptimizedTokens(ExpressionChars, ParserSettings);
ExpressionGroup.Expressions[ExpressionId] = onpExpression;
// zamiania znaków równości na wołanie funkcji
List <ExpressionTokens> resultTokens = new List <ExpressionTokens>();
while (true)
{
ExpressionTokens setTokens = TakeSetTokens(
onpExpression.Tokens);
if (setTokens == null)
{
break;
}
resultTokens.Insert(0, setTokens);
}
Expression currentExpression = onpExpression;
foreach (ExpressionTokens resultToken in resultTokens)
{
Expression setExpression = new Expression();
setExpression.IsOnpExecution = false;
setExpression.Tokens = resultToken;
ExpressionGroup.Expressions[setExpression.ID] = setExpression;
PrepareExpressions(
setExpression,
ParserSettings,
ExpressionGroup);
CorrectSetExpression(
setExpression,
currentExpression.ID,
ParserSettings,
ExpressionGroup);
currentExpression = setExpression;
}
ExpressionGroup.MainExpression = currentExpression;
PrepareExpressions(
onpExpression,
ParserSettings,
ExpressionGroup);
}
catch (Exception ex)
{
throw new DynLanCompileException(
"Error in expression: '" + new string(Linq2.ToArray(ExpressionChars), 0, ExpressionChars.Count).Replace("'", "\\'") + "'; " + ex.Message,
ex);
}
}
////////////////////////////
/// <summary>
/// Ustala kolejnośc tokenów zgodną z ONP
/// </summary>
private ExpressionTokens TransformToOnp(
IList <ExpressionToken> Tokens,
ParserSettings ParserSettings)
{
ExpressionTokens onpTokens = new ExpressionTokens();
// defaul settings
if (ParserSettings == null)
{
ParserSettings = new ParserSettings();
}
// przygotowanie stosu
Stack <ExpressionToken> _tokenStack = new Stack <ExpressionToken>();
// ONP
for (int i = 0; i < Tokens.Count; i++)
{
ExpressionToken token = Tokens[i];
if (token.TokenType == TokenType.VALUE ||
token.TokenType == TokenType.PROPERTY_NAME ||
token.TokenType == TokenType.VARIABLE ||
/*token.TokenType == TokenType.FUNCTION_CALL ||*/
token.TokenType == TokenType.WHITESPACE)
{
onpTokens.Add(token);
}
else if (token.TokenType == TokenType.BRACKET_BEGIN)
{
_tokenStack.Push(token);
}
else if (token.TokenType == TokenType.OPERATOR)
{
while (_tokenStack.Count > 0)
{
var lV = _tokenStack.Peek();
if (lV.Priority >= token.Priority)
{
_tokenStack.Pop();
onpTokens.Add(lV);
}
else
{
break;
}
}
_tokenStack.Push(token);
}
else if (token.TokenType == TokenType.BRACKET_END)
{
while (_tokenStack.Count > 0)
{
var lV = _tokenStack.Peek();
if (lV.TokenType == TokenType.BRACKET_BEGIN)
{
_tokenStack.Pop();
break;
}
else
{
_tokenStack.Pop();
onpTokens.Add(lV);
}
}
}
}
while (_tokenStack.Count > 0)
{
onpTokens.Add(_tokenStack.Pop());
}
return(onpTokens);
}
public override void ProcessExpression(ExpressionTokens expressionTokens)
{
throw new System.NotImplementedException();
}
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--;
* }
* }*/
}
private static void ValidateTokens(
ExpressionTokens tokens)
{
// usunięcie operatorów na końcu
for (int i = tokens.Count - 1; i >= 0; i--)
{
ExpressionToken currentToken = tokens[i];
if (currentToken.TokenType == TokenType.OPERATOR)
{
// tokens.RemoveAt(i);
throw new DynLanIncorrectExpressionFormatException("Invalid operator " + currentToken.TokenName + " at the end of expression!");
}
else
{
break;
}
}
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 DynLanIncorrectExpressionFormatException("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 DynLanIncorrectExpressionFormatException("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 DynLanIncorrectExpressionFormatException("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 DynLanIncorrectExpressionFormatException("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 DynLanIncorrectExpressionFormatException("Number of opening brackets is not equal with number of ending brackets");
}
}
/// <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 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();
}
}
}
