Пример #1
0
        private void EvaluateParameters(ParameteriseNode statement, IDictionary <string, ParameterContext> context)
        {
            parameterIndex = 0;
            AnalysedToken token = null;

            ParameterContext.Builder repetableParameter = null;

            while (!wrongInput &&
                   parameterIndex < statement.Parameters.Count &&
                   tokenStack.Count > 0)
            {
                token = tokenStack.Peek();
                ParameterNode parameter = statement.Parameters[parameterIndex];

                if (token.IsEndOfParameterList)
                {
                    if (parameter.Parameter.IsRepeatable || parameter.Parameter.IsOptional)
                    {
                        AddTokenToResult(TokenTypeEnum.EndOfParameterList, token.RawInput);
                        tokenStack.Pop();
                        break;
                    }

                    AddWrongTokenToResult(token.RawInput);
                    return;
                }

                if (parameter.Parameter.IsOptional)
                {
                    if (!IsParameterMatch(parameter, token))
                    {
                        parameterIndex++;
                        continue;
                    }

                    AddTokenToResult(TokenTypeEnum.Parameter, token.RawInput, token.Value);
                    tokenStack.Pop();

                    if (parameter.Parameter.IsRepeatable)
                    {
                        if (repetableParameter == null)
                        {
                            repetableParameter     = ParameterContext.Empty.ToBuilder();
                            repetableParameter.Key = parameter.Parameter.Key;
                        }

                        repetableParameter.Values.Add(token.Value);
                    }
                    else
                    {
                        context[parameter.Parameter.Key] = ParameterContext.Build(parameter.Parameter.Key, token.Value);
                        parameterIndex++;
                    }
                }
                else
                {
                    if (!IsParameterMatch(parameter, token))
                    {
                        if (repetableParameter == null)
                        {
                            AddWrongTokenToResult(token.RawInput);
                            return;
                        }

                        break;
                    }

                    AddTokenToResult(TokenTypeEnum.Parameter, token.RawInput, token.Value);
                    tokenStack.Pop();

                    if (parameter.Parameter.IsRepeatable)
                    {
                        if (repetableParameter == null)
                        {
                            repetableParameter     = ParameterContext.Empty.ToBuilder();
                            repetableParameter.Key = parameter.Parameter.Key;
                        }

                        repetableParameter.Values.Add(token.Value);
                    }
                    else
                    {
                        context[parameter.Parameter.Key] = ParameterContext.Build(parameter.Parameter.Key, token.Value);
                        parameterIndex++;
                    }
                }
            }

            if (repetableParameter != null)
            {
                context[repetableParameter.Key] = repetableParameter.ToImmutable();
            }

            if (!wrongInput &&
                statement.Type == NodeTypeEnum.Query)
            {
                if (tokenStack.Peek().IsEndOfInput)
                {
                    tokenStack.Pop();
                }

                if (tokenStack.Count > 0)
                {
                    if (token != null &&
                        !token.IsEndOfParameterList)
                    {
                        AddWrongTokenToResult(token.RawInput);
                    }

                    if (statement.Parameters.Count < 1)
                    {
                        AddWrongTokenToResult(tokenStack.Peek().RawInput);
                    }
                }
            }
        }