コード例 #1
0
        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);
        }
コード例 #2
0
        ////////////////////////////

        /// <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);
        }
コード例 #3
0
        ////////////////////////////////////////////////////////

        public static IEnumerable <String> SplitMethodParameters(String Code, Boolean AllObjects = false)
        {
            StringBuilder paramStr = new StringBuilder();
            Boolean       isFirst  = true;

            IList <String> tokens = TokenGetter.
                                    GetStringTokens(Code.Trim()).
                                    ToList();

            foreach (String token in tokens)
            {
                if (token.EndsWith(","))
                {
                    if (!isFirst && AllObjects)
                    {
                        yield return(",");
                    }

                    isFirst = false;
                    paramStr.Append(token.Substring(0, token.Length - 1));
                    yield return(paramStr.ToString());

                    paramStr.Remove(0, paramStr.Length);
                }
                else
                {
                    paramStr.Append(token);
                }
            }
            if (paramStr.Length > 0)
            {
                if (!isFirst && AllObjects)
                {
                    yield return(",");
                }

                yield return(paramStr.ToString());
            }
        }