C# (CSharp) ParseTreePrinter Exemples

Exemple #1

        public void PrintsComplexTree()
        {
            var input = new SyntaxNodeWithChildren(
                SyntaxKind.BinaryExpression,
                new SyntaxNodeWithChildren(
                    SyntaxKind.BinaryExpression,
                    new SyntaxToken(SyntaxKind.NumberToken, 0, "", 7),
                    new SyntaxToken(SyntaxKind.SlashToken, 0, ""),
                    new SyntaxToken(SyntaxKind.NumberToken, 0, "", 3)
                    ),
                new SyntaxToken(SyntaxKind.MinusToken, 0, ""),
                new SyntaxNodeWithChildren(
                    SyntaxKind.BinaryExpression,
                    new SyntaxToken(SyntaxKind.NumberToken, 0, "", 2),
                    new SyntaxToken(SyntaxKind.StarToken, 0, ""),
                    new SyntaxToken(SyntaxKind.NumberToken, 0, "", 0)
                    )
                );

            var result = ParseTreePrinter.PrettyPrint(input);

            Assert.That(result, Is.EqualTo(@"
BinaryExpression
 ├─BinaryExpression
 │  ├─NumberToken: 7
 │  ├─SlashToken
 │  └─NumberToken: 3
 ├─MinusToken
 └─BinaryExpression
    ├─NumberToken: 2
    ├─StarToken
    └─NumberToken: 0".TrimStart()));
        }

Exemple #2

        public void PrintsSingleTokenWithoutValue()
        {
            var input = new SyntaxToken(SyntaxKind.PlusToken, 73, "something");

            var result = ParseTreePrinter.PrettyPrint(input);

            Assert.That(result, Is.EqualTo("PlusToken"));
        }

Exemple #3

        public void PrintsSingleTokenWithValue()
        {
            var input = new SyntaxToken(SyntaxKind.BadToken, 73, "foobar", 123);

            var result = ParseTreePrinter.PrettyPrint(input);

            Assert.That(result, Is.EqualTo("BadToken: 123"));
        }

Exemple #4

        private static void PrintParseTree(SyntaxTree syntaxTree)
        {
            WriteToConsole(ConsoleColor.DarkGray, "Parse Tree:");
            Console.WriteLine();

            ParseTreePrinter.PrettyPrint(syntaxTree.Root, Console.Out, firstLinePrefix: "    ", furtherLinePrefix: "    ");
            Console.WriteLine();
        }

Exemple #5

        public void PrintsNodeWithSingleChild()
        {
            var input = new SyntaxNodeWithChildren(
                SyntaxKind.LiteralExpression,
                new SyntaxToken(SyntaxKind.NumberToken, 0, "", 42)
                );

            var result = ParseTreePrinter.PrettyPrint(input);

            Assert.That(result, Is.EqualTo(@"
LiteralExpression
 └─NumberToken: 42".TrimStart()));
        }

Exemple #6

        public void PrintsNodeWithMultipleChildren()
        {
            var input = new SyntaxNodeWithChildren(
                SyntaxKind.LiteralExpression,
                new SyntaxToken(SyntaxKind.MinusToken, 0, ""),
                new SyntaxToken(SyntaxKind.NumberToken, 0, "", "72")
                );

            var result = ParseTreePrinter.PrettyPrint(input);

            Assert.That(result, Is.EqualTo(@"
LiteralExpression
 ├─MinusToken
 └─NumberToken: 72".TrimStart()));
        }

Exemple #7

        public void PrintsNodeWithNestedChild()
        {
            var input = new SyntaxNodeWithChildren(
                SyntaxKind.LiteralExpression,
                new SyntaxNodeWithChildren(
                    SyntaxKind.LiteralExpression,
                    new SyntaxToken(SyntaxKind.MinusToken, 0, "")
                    )
                );

            var result = ParseTreePrinter.PrettyPrint(input);

            Assert.That(result, Is.EqualTo(@"
LiteralExpression
 └─LiteralExpression
    └─MinusToken".TrimStart()));
        }

Exemple #8

        public void PrintsTwoChildrenWhenFirstHasChild()
        {
            var input = new SyntaxNodeWithChildren(
                SyntaxKind.LiteralExpression,
                new SyntaxNodeWithChildren(
                    SyntaxKind.LiteralExpression,
                    new SyntaxToken(SyntaxKind.LiteralToken, 0, "")
                    ),
                new SyntaxToken(SyntaxKind.SingleLineCommentToken, 0, "")
                );

            var result = ParseTreePrinter.PrettyPrint(input);

            Assert.That(result, Is.EqualTo(@"
LiteralExpression
 ├─LiteralExpression
 │  └─LiteralToken
 └─SingleLineCommentToken".TrimStart()));
        }

Exemple #9

Fichier : Pascal.cs Projet : ajinkyakulkarni/Pascal_Interpreter

        private Backend backend;  // backend

        public Pascal(string operation, string filePath, string flags)
        {
            try
            {
                bool intermediate = flags.IndexOf('i') > -1;
                bool xref         = flags.IndexOf('x') > -1;

                source = new Source(new StreamReader(filePath));
                source.addMessageListener(new SourceMessageListener());

                parser = FrontendFactory.createParser("Pascal", "top-down", source);
                parser.addMessageListener(new ParserMessageListener());

                backend = BackendFactory.createBackend(operation);
                backend.addMessageListener(new BackendMessageListener());

                parser.parse();
                source.close();

                iCode            = parser.iCode;
                symbolTableStack = Parser.symbolTableStack;

                if (xref)
                {
                    CrossReferencer crossReferencer = new CrossReferencer();
                    crossReferencer.Print(symbolTableStack);
                }

                if (intermediate)
                {
                    ParseTreePrinter treePrinter = new ParseTreePrinter(Console.Out);
                    treePrinter.Print(iCode);
                }
                backend.process(iCode, symbolTableStack);
            }

            catch (Exception e)
            {
                Console.WriteLine("***** Internal translator error. *****");
                Console.WriteLine(e.StackTrace);
            }
        }