Exemplo n.º 1
0
  @Test
  public void test() {
    Grammar grammar =
        Grammar.builder()

            // $default$ ::=  {UNDEFINED,-1,NON_REC} PREC(1,1)
            .addRule(
                Rule.withHead(Nonterminal.builder("$default$").build())
                    .setLayoutStrategy(NO_LAYOUT)
                    .setRecursion(Recursion.NON_REC)
                    .setAssociativity(Associativity.UNDEFINED)
                    .setPrecedence(-1)
                    .setPrecedenceLevel(
                        PrecedenceLevel.from(
                            1,
                            1,
                            -1,
                            false,
                            false,
                            false,
                            new Integer[] {},
                            false,
                            new Integer[] {}))
                    .build())
            // E ::= E (^) E  {LEFT,1,LEFT_RIGHT_REC} LEFT(1,1,1) PREC(1,1)
            .addRule(
                Rule.withHead(Nonterminal.builder("E").build())
                    .addSymbol(Nonterminal.builder("E").build())
                    .addSymbol(
                        Terminal.builder(Sequence.builder(Character.builder(94).build()).build())
                            .build())
                    .addSymbol(Nonterminal.builder("E").build())
                    .setRecursion(Recursion.LEFT_RIGHT_REC)
                    .setAssociativity(Associativity.LEFT)
                    .setPrecedence(1)
                    .setAssociativityGroup(
                        new AssociativityGroup(
                            Associativity.LEFT,
                            PrecedenceLevel.from(
                                1,
                                1,
                                -1,
                                true,
                                false,
                                false,
                                new Integer[] {},
                                false,
                                new Integer[] {}),
                            1,
                            1,
                            1))
                    .setPrecedenceLevel(
                        PrecedenceLevel.from(
                            1,
                            1,
                            -1,
                            true,
                            false,
                            false,
                            new Integer[] {},
                            false,
                            new Integer[] {}))
                    .build())
            // E ::= (-) E  {UNDEFINED,1,RIGHT_REC} LEFT(1,1,1) PREC(1,1)
            .addRule(
                Rule.withHead(Nonterminal.builder("E").build())
                    .addSymbol(
                        Terminal.builder(Sequence.builder(Character.builder(45).build()).build())
                            .build())
                    .addSymbol(Nonterminal.builder("E").build())
                    .setRecursion(Recursion.RIGHT_REC)
                    .setAssociativity(Associativity.UNDEFINED)
                    .setPrecedence(1)
                    .setAssociativityGroup(
                        new AssociativityGroup(
                            Associativity.LEFT,
                            PrecedenceLevel.from(
                                1,
                                1,
                                -1,
                                true,
                                false,
                                false,
                                new Integer[] {},
                                false,
                                new Integer[] {}),
                            1,
                            1,
                            1))
                    .setPrecedenceLevel(
                        PrecedenceLevel.from(
                            1,
                            1,
                            -1,
                            true,
                            false,
                            false,
                            new Integer[] {},
                            false,
                            new Integer[] {}))
                    .build())
            // E ::= (+) E  {UNDEFINED,1,RIGHT_REC} LEFT(1,1,1) PREC(1,1)
            .addRule(
                Rule.withHead(Nonterminal.builder("E").build())
                    .addSymbol(
                        Terminal.builder(Sequence.builder(Character.builder(43).build()).build())
                            .build())
                    .addSymbol(Nonterminal.builder("E").build())
                    .setRecursion(Recursion.RIGHT_REC)
                    .setAssociativity(Associativity.UNDEFINED)
                    .setPrecedence(1)
                    .setAssociativityGroup(
                        new AssociativityGroup(
                            Associativity.LEFT,
                            PrecedenceLevel.from(
                                1,
                                1,
                                -1,
                                true,
                                false,
                                false,
                                new Integer[] {},
                                false,
                                new Integer[] {}),
                            1,
                            1,
                            1))
                    .setPrecedenceLevel(
                        PrecedenceLevel.from(
                            1,
                            1,
                            -1,
                            true,
                            false,
                            false,
                            new Integer[] {},
                            false,
                            new Integer[] {}))
                    .build())
            // E ::= (a)  {UNDEFINED,-1,NON_REC} PREC(1,1)
            .addRule(
                Rule.withHead(Nonterminal.builder("E").build())
                    .addSymbol(
                        Terminal.builder(Sequence.builder(Character.builder(97).build()).build())
                            .build())
                    .setRecursion(Recursion.NON_REC)
                    .setAssociativity(Associativity.UNDEFINED)
                    .setPrecedence(-1)
                    .setPrecedenceLevel(
                        PrecedenceLevel.from(
                            1,
                            1,
                            -1,
                            true,
                            false,
                            false,
                            new Integer[] {},
                            false,
                            new Integer[] {}))
                    .build())
            // E ::= E (*) E  {UNDEFINED,2,LEFT_RIGHT_REC} PREC(2,2)
            .addRule(
                Rule.withHead(Nonterminal.builder("E").build())
                    .addSymbol(Nonterminal.builder("E").build())
                    .addSymbol(
                        Terminal.builder(Sequence.builder(Character.builder(42).build()).build())
                            .build())
                    .addSymbol(Nonterminal.builder("E").build())
                    .setRecursion(Recursion.LEFT_RIGHT_REC)
                    .setAssociativity(Associativity.UNDEFINED)
                    .setPrecedence(2)
                    .setPrecedenceLevel(
                        PrecedenceLevel.from(
                            2,
                            2,
                            2,
                            false,
                            false,
                            true,
                            new Integer[] {1},
                            false,
                            new Integer[] {}))
                    .build())
            // S ::= E  {UNDEFINED,-1,NON_REC} PREC(1,1)
            .addRule(
                Rule.withHead(Nonterminal.builder("S").build())
                    .addSymbol(Nonterminal.builder("E").build())
                    .setRecursion(Recursion.NON_REC)
                    .setAssociativity(Associativity.UNDEFINED)
                    .setPrecedence(-1)
                    .setPrecedenceLevel(
                        PrecedenceLevel.from(
                            1,
                            1,
                            -1,
                            false,
                            false,
                            false,
                            new Integer[] {},
                            false,
                            new Integer[] {}))
                    .build())
            .build();

    grammar = new DesugarPrecedenceAndAssociativity().transform(grammar);
    System.out.println(grammar.toStringWithOrderByPrecedence());

    Input input = Input.fromString("a^-a");
    GrammarGraph graph = GrammarGraph.from(grammar, input, Configuration.DEFAULT);

    // Visualization.generateGrammarGraph("test/org/iguana/parser/datadependent/precedence/",
    // graph);

    ParseResult result = Iguana.parse(input, graph, Nonterminal.withName("S"));

    Assert.assertTrue(result.isParseSuccess());

    // Visualization.generateSPPFGraph("test/org/iguana/parser/datadependent/precedence/",
    //                   result.asParseSuccess().getSPPFNode(), input);

    Assert.assertEquals(0, result.asParseSuccess().getStatistics().getCountAmbiguousNodes());
  }