Catrobat.IDE.Core.Formulas.FormulaInterpreter.InterpretChildren C# (CSharp) Method

        private void InterpretChildren(IFormulaToken commonToken, List<IFormulaToken> parenthesesTokens)
        {
            SetOrigin(commonToken, parenthesesTokens);

            // children are all tokens except the enclosing parentheses
            var children = parenthesesTokens.GetRange(1, parenthesesTokens.Count - 2);

            // interpret FormulaTokenParameter
            var parameterToken = commonToken as FormulaTokenParameter;
            if (parameterToken != null)
            {
                var unaryParameterToken = parameterToken as FormulaTokenUnaryParameter;
                var binaryParameterToken = parameterToken as FormulaTokenBinaryParameter;
                var parametersCount = unaryParameterToken != null ? 1 : 2;

                var interpretedChildren = children.AsEnumerable();
                interpretedChildren = InterpretNumbers(interpretedChildren, lookAhead: children);
                interpretedChildren = InterpretFunctions(interpretedChildren);
                interpretedChildren = InterpretMinusTokenForward(interpretedChildren);
                interpretedChildren = InterpretOperators(interpretedChildren, lookAhead: children);
                interpretedChildren = InterpretParameters(interpretedChildren);
                var parameters = interpretedChildren.Cast<FormulaTree>().Take(parametersCount).ToList();

                // valid parameters
                if (IsCancellationRequested) return;
                if (parameters.Count == 0)
                {
                    SetParsingError(
                        source: Range.Empty(GetOrigin(parenthesesTokens.First()).End),
                        message: AppResourcesHelper.Get("FormulaInterpreter_Brackets_EmptyArgument"));
                    return;
                }
                if (parameters.Count < parametersCount)
                {
                    SetParsingError(
                        source: Range.Empty(GetOrigin(parenthesesTokens.Last()).Start),
                        message: AppResourcesHelper.Get("FormulaInterpreter_Brackets_TooFewArguments"));
                    return;
                }
                var parametersRange = GetOrigin(parameters);
                if (parametersRange.Length < GetOrigin(children).Length)
                {
                    var nextIndex = parametersRange.End;
                    var nextToken = children.First(child => GetOrigin(child).Start == nextIndex);
                    if (nextToken is FormulaTokenParameterSeparator)
                    {
                        SetParsingError(
                            source: Range.FromLength(parametersRange.End, GetOrigin(children).Length - parametersRange.Length),
                            message: AppResourcesHelper.Get("FormulaInterpreter_Brackets_TooManyArguments"));
                    }
                    else
                    {
                        SetParsingError(
                            source: Range.Empty(parametersRange.End),
                            message: AppResourcesHelper.Get("FormulaInterpreter_Brackets_ArgumentDoubleValue"));
                    }
                    return;
                }

                // attach parameters
                if (unaryParameterToken != null)
                {
                    unaryParameterToken.Parameter = RemoveParentheses(parameters[0]);
                }
                if (binaryParameterToken != null)
                {
                    binaryParameterToken.FirstParameter = RemoveParentheses(parameters[0]);
                    binaryParameterToken.SecondParameter = RemoveParentheses(parameters[1]);
                }
            }

            // interpret FormulaNodeParentheses
            var parenthesesNode = commonToken as FormulaNodeParentheses;
            if (parenthesesNode != null)
            {
                var interpretedChildren = children.AsEnumerable();
                interpretedChildren = InterpretNonParameter(interpretedChildren);
                interpretedChildren = InterpretNumbers(interpretedChildren, lookAhead: children);
                interpretedChildren = InterpretFunctions(interpretedChildren);
                interpretedChildren = InterpretMinusTokenForward(interpretedChildren);
                interpretedChildren = InterpretOperators(interpretedChildren, lookAhead: children);
                var child = (FormulaTree) interpretedChildren.FirstOrDefault();

                // valid child
                if (IsCancellationRequested) return;
                if (child == null)
                {
                    SetParsingError(
                        source: Range.Empty(GetOrigin(parenthesesTokens.Last()).Start),
                        message: AppResourcesHelper.Get("FormulaInterpreter_Brackets_EmptyParentheses"));
                    return;
                }
                var childRange = GetOrigin(child);
                if (childRange.Length < GetOrigin(children).Length)
                {
                    SetParsingError(
                        source: Range.Empty(childRange.End),
                        message: AppResourcesHelper.Get("FormulaInterpreter_DoubleValue"));
                    return;
                }

                // attach child
                parenthesesNode.Child = RemoveParentheses(child);
            }

        }