コード例 #1
0
            protected override void VisitLiftExpression(LiftExpression expression)
            {
                CS.IndentInOut(
                    "LiftExpression",
                    () =>
                {
                    VisitExpression(expression.Expression);
                    CS.If(
                        $"{Locals.Result}.IsSuccess",
                        () =>
                    {
                        using var nodes = Locals.Use("nodes");
                        using var node  = Locals.Use("node");
                        CS.Ln($"{nodes} = new List<INode>(10);");
                        CS.ForEach(
                            $"{node} in {Locals.Result}.Nodes",
                            () =>
                        {
                            CS.Ln($"{nodes}.AddRange({node}.Children);");
                        });

                        CS.Ln($"{Locals.Result} = Result.Success({Locals.Result}, {Locals.Result}.Next, {nodes}.ToArray());");
                    });
                });
            }
コード例 #2
0
            private static Expression Expression(INode node)
            {
                switch (node.Name)
                {
                case "sequence": return(Sequence(node));

                case "choice": return(Choice(node));

                case "prefix.drop": return(DropExpression.From(node[0], Expression(node[0])));

                case "prefix.lift": return(LiftExpression.From(node[0], Expression(node[0])));

                case "prefix.fuse": return(FuseExpression.From(node[0], Expression(node[0])));

                case "prefix.not": return(NotExpression.From(node[0], Expression(node[0])));

                case "suffix.zero-or-more": return(StarExpression.From(node[0], Expression(node[0])));

                case "suffix.one-or-more": return(PlusExpression.From(node[0], Expression(node[0])));

                case "suffix.zero-or-one": return(OptionalExpression.From(node[0], Expression(node[0])));

                case "inline": return(InlineExpression.From(node[0], Tree.Rule.From(Identifier(node[0]), Expression(node[1]))));

                case "identifier": return(NameExpression.From(node, Identifier(node)));

                case "any": return(AnyExpression.From(node));

                case "verbatim-string": return(StringLiteralExpression.From(node, ((ILeaf)node).Value));

                case "character-class": return(Class(node));

                case "string": return(String(node));

                default:
                    throw new NotImplementedException();
                }
            }
コード例 #3
0
        private Expression Prefix(INode node)
        {
            switch (node.Name)
            {
            case "and":
                return(AndExpression.From(node, Suffix(node[0])));

            case "not":
                return(NotExpression.From(node, Suffix(node[0])));

            case "lift":
                return(LiftExpression.From(node, Suffix(node[0])));

            case "drop":
                return(DropExpression.From(node, Suffix(node[0])));

            case "fuse":
                return(FuseExpression.From(node, Suffix(node[0])));

            default:
                return(Suffix(node));
            }
        }
コード例 #4
0
 protected override void VisitLiftExpression(LiftExpression expression)
 {
     Writer.Write($"{OpSymbols.Lift}");
     MaybeParent(expression.Expression is PrefixExpression, expression.Expression);
 }
コード例 #5
0
            protected override void VisitLiftExpression(LiftExpression expression)
            {
                base.VisitLiftExpression(expression);

                Push(new Lift(Pop()));
            }
コード例 #6
0
 protected override void VisitLiftExpression(LiftExpression expression)
 {
     base.VisitLiftExpression(expression);
     SetNullable(expression, expression.Expression.Attr.IsNullable);
 }