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(); } } }