Ejemplo n.º 1
0
        private static void FormatNakedFunctionCallExpression(int prefixLength, StringBuilder builder, NakedFunctionCallExpression nakedFunctionCallExpression, int count)
        {
            builder.AppendLine(AddPrefix(prefixLength, $"functionName:{nakedFunctionCallExpression.NakedFunction.Name}"));
            builder.AppendLine(AddPrefix(prefixLength, "arguments:"));
            var nakedFunctionArguments = nakedFunctionCallExpression.Arguments;

            for (var i = 0; i < nakedFunctionArguments.Length; i++)
            {
                builder.AppendLine(AddPrefix(prefixLength + count, $"{i}:"));
                Format(nakedFunctionArguments[i], prefixLength + 2 * count, builder);
            }
        }
Ejemplo n.º 2
0
            private EvaluableExpression GetVariable()
            {
                var chr  = se[index];
                var expr = chr == openParen?GetGroup() : GetIdentifier();

                SkipSpaces();
                chr = se[index];
                var start = index;

                while (true)
                {
                    if (chr == period)
                    {
                        if (option.NotAllowedMemberExpression)
                        {
                            throw new ParseException($"Member expression is not allowed at character {index}");
                        }
                        index++;
                        SkipSpaces();
                        expr = new ObjectMemberExpression(expr, GetIdentifier(), start, index, false);
                        SkipSpaces();
                        chr = se[index];
                    }
                    else if (chr == openSquareBracket)
                    {
                        if (option.NotAllowedIndexerExpression)
                        {
                            throw new ParseException($"Indexer expression is not allowed at character {index}");
                        }
                        index++;
                        expr = new ObjectMemberExpression(expr, GetExpression(), start, index, true);
                        SkipSpaces();
                        chr = se[index];
                        if (chr != closeSquareBracket)
                        {
                            throw new ParseException($"Unclosed [ at character {index}");
                        }
                        index++;
                        SkipSpaces();
                        chr = se[index];
                    }
                    else if (chr == openParen)
                    {
                        index++;
                        switch (expr)
                        {
                        case ObjectMemberExpression callee:
                            expr = new ObjectsFunctionCallExpression(callee, GetArguments(closeParen), start, index);
                            break;

                        case IdentifierExpression identifier:
                            var name     = identifier.Name;
                            var function = option.NakedFunctions.FirstOrDefault(f => f.Name == name);
                            if (function == null)
                            {
                                throw new ParseException($"Can not find naked function ({name}) at character {index - name.Length - 1}");
                            }
                            expr = new NakedFunctionCallExpression(function, GetArguments(closeParen), start, index);
                            break;
                        }
                        SkipSpaces();
                        chr = se[index];
                    }
                    else
                    {
                        break;
                    }
                }
                return(expr);
            }