Java Parboiled.createParser方法代码示例

import org.parboiled.Parboiled; //导入方法依赖的package包/类
public static void main(String... args) {

    Parser templateParser = Parboiled.createParser(Parser.class);
    ParsingResult<Object> result = new ReportingParseRunner<>(templateParser.Unit()).run(input2);

    ImmutableList<Object> copy = ImmutableList.copyOf(result.valueStack.iterator());

    if (!copy.isEmpty()) {
      Unit unit = (Unit) copy.get(0);

      Unit balance = Balancing.balance(unit);
      System.out.println(balance);
    }

    if (result.hasErrors()) {
      System.err.println(ErrorUtils.printParseErrors(result.parseErrors));
    }
    // System.out.println(ParseTreeUtils.printNodeTree(result));
  }
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
public void setUp() {
    String input = getFile("src/test/resources/test.query");
    System.out.println(input);
    DELPParser parser = Parboiled.createParser(DELPParser.class);

    parser.setResolver(IRIResolver.create());

    ParsingResult<OBEPQuery> result = new ReportingParseRunner(parser.Query()).run(input);

    if (result.hasErrors()) {
        System.out.println("Errors have been found!");
        for (ParseError arg : result.parseErrors) {
            System.out.println(input.substring(0, arg.getStartIndex()) + "|->" + input.substring(arg.getStartIndex(), arg.getEndIndex()) + "<-|" + input.substring(arg.getEndIndex(), input.length() - 1));
        }
    }

    OBEPQueryImpl q = (OBEPQueryImpl) result.resultValue;
    for (EventDecl event : q.getEventCalculusDecls()) {
        EventCalculusDecl ecd = (EventCalculusDecl) event;
        System.out.println(ecd);
    }
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
public void setUp() {
    testEngine = new OBEPTestEngine();

    cep = new EventProcessorImpl();
    cep.init(testEngine);
    String input = getFile("src/test/resources/test2.query");
    DELPParser parser = Parboiled.createParser(DELPParser.class);

    parser.setResolver(IRIResolver.create());

    ParsingResult<OBEPQuery> result = new ReportingParseRunner(parser.Query()).run(input);

    if (result.hasErrors()) {
        System.out.println("Errors have been found!");
        for (ParseError arg : result.parseErrors) {
            System.out.println(input.substring(0, arg.getStartIndex()) + "|->" + input.substring(arg.getStartIndex(), arg.getEndIndex()) + "<-|" + input.substring(arg.getEndIndex(), input.length() - 1));
        }
    }

    OBEPQuery q = result.resultValue;
    cep.registerQuery(q);
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
public static void main(String[] arg) throws Exception{
    PegParser parser  = Parboiled.createParser(PegParser.class);

    String peg = "";

    try (
            BufferedReader reader = Files.newBufferedReader(Paths.get(arg[0]))
    ) {
        String line = "";
        while ((line = reader.readLine())!=null) {

            peg += line + "\n";
        }
    }


    AstToJava astToJava = new AstToJava(arg[1]);
    String java = astToJava.toJava(parser.parse(peg));

    try (
            BufferedWriter writer = Files.newBufferedWriter(Paths.get(arg[1]+".java"))
    ) {
        writer.write(java);
    }
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
@Test
public void testToJava() throws Exception {
    PegParser parser  = Parboiled.createParser(PegParser.class);

    String peg = "";

    try (
            BufferedReader reader = Files.newBufferedReader(Paths.get("src/main/resources/peg.peg"))
    ) {
        String line = "";
        while ((line = reader.readLine())!=null) {

            peg += line + "\n";
        }
    }

    String clsName = "GramExp";


    AstToJava astToJava = new AstToJava(clsName);
    String java = astToJava.toJava(parser.parse(peg));

    assertEquals(expected, java);
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
/**
 * Parses an XPath Expression and generates an AST
 *
 * @param xpath The XPath to parse
 * @param out Either a print stream for receiving a debug print of the NodeTree generated by the parser, or null otherwise
 * @param err Either a print stream for receiving errors that occurred during parsing or null otherwise
 *
 * @return An {@link Expr} which is the root of the generated AST
 */
public static Expr parseXPath(final String xpath, final PrintStream out, final PrintStream err) {
    final XPathParser parser = Parboiled.createParser(XPathParser.class, Boolean.TRUE);
    final ParseRunner<ASTNode> parseRunner = new RecoveringParseRunner<ASTNode>(parser.withEOI(parser.XPath()));
    final ParsingResult<ASTNode> result = parseRunner.run(xpath + Chars.EOI);

    if(out != null) {
        final String parseTreePrintOut = ParseTreeUtils.printNodeTree(result);
        out.print(parseTreePrintOut);
    }

    if(err != null) {
        final String errors = printParseErrors(result);
        err.print(errors);
    }

    return (Expr)result.parseTreeRoot.getValue();
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
public static Ndfa<Character> parse(String text) {
    if (text == null) {
        return NfaUtils.<Character>createEmptyLanguageNfa();
    }

    if (text.equals("")) {
        return NfaUtils.<Character>createEmptyStringNfa();
    }

    final RegexpParser parser = Parboiled.createParser(RegexpParser.class);
    final ParsingResult<?> result = new ReportingParseRunner(parser.regexp()).run(text);

    if (!result.matched || result.parseTreeRoot.getEndIndex() < text.length()) {
        throw new IllegalArgumentException("Could not parse: " + text);
    }

    return NfaUtils.minimize(RegexpNodeTreeParser.getNfaBase(result.parseTreeRoot, text));
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
@Test
public void testJavaError2() {
    String sourceWithErrors = "package org.parboiled.examples;\n" +
            "public class JavaTestSource {\n" +
            "    @SuppressWarnings({\"UnnecessaryLocalVariable\", \"UnusedDeclaration\"})\n" +
            "    public String method(int param) {\n" +
            "        String name  toString();\n" +
            "        return name;\n" +
            "    }\n" +
            "}";

    JavaParser parser = Parboiled.createParser(JavaParser.class);
    Rule rule = parser.CompilationUnit();
    ParsingResult result = new ReportingParseRunner(rule).run(sourceWithErrors);
    assertEquals(result.parseErrors.size(), 1);
    assertEquals(printParseErrors(result), "" +
            "Invalid input 't', expected Whitespace, \"/*\", \"//\", Dim, '=', ',' or ';' (line 5, pos 22):\n" +
            "        String name  toString();\n" +
            "                     ^\n");
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
@Test
public void threeDimensionalMeasured() {
    WKTParser parser = Parboiled.createParser(WKTParser.class);
    ParsingResult<Geometry> result = new ReportingParseRunner(parser.WKT()).run("POINT ZM (1 2 3 4)");
    Geometry geometry = result.resultValue;
    assertNotNull(geometry);
    assertTrue(geometry instanceof Point);
    Point point = (Point) geometry;
    assertEquals(Dimension.ThreeMeasured, point.getDimension());
    assertFalse(point.getCoordinate().isEmpty());
    assertTrue(point.getCoordinate().getDimension() == Dimension.ThreeMeasured);
    assertEquals(1, point.getCoordinate().getX(), 0.001);
    assertEquals(2, point.getCoordinate().getY(), 0.001);
    assertEquals(3, point.getCoordinate().getZ(), 0.001);
    assertEquals(4, point.getCoordinate().getM(), 0.001);
    assertNull(point.getSrid());
    assertEquals("POINT ZM (1.0 2.0 3.0 4.0)", point.toString());
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
@Test
public void twoDimensionalMeasured() {
    WKTParser parser = Parboiled.createParser(WKTParser.class);
    ParsingResult<Geometry> result = new ReportingParseRunner(parser.WKT()).run("GEOMETRYCOLLECTION M (POINT(4 6 3),LINESTRING(4 6 2,7 10 4))");
    Geometry geometry = result.resultValue;
    assertNotNull(geometry);
    assertTrue(geometry instanceof GeometryCollection);
    GeometryCollection gc = (GeometryCollection) geometry;
    assertEquals(Dimension.TwoMeasured, gc.getDimension());
    assertNull(gc.getSrid());
    assertEquals(2, gc.getGeometries().size());
    // 0
    Point point = (Point) gc.getGeometries().get(0);
    assertEquals(Dimension.TwoMeasured, point.getDimension());
    assertEquals(Coordinate.create2DM(4, 6, 3), point.getCoordinate());
    // 1
    LineString line = (LineString) gc.getGeometries().get(1);
    assertEquals(Dimension.TwoMeasured, line.getDimension());
    assertEquals(2, line.getCoordinates().size());
    assertEquals(Coordinate.create2DM(4, 6, 2), line.getCoordinates().get(0));
    assertEquals(Coordinate.create2DM(7, 10, 4), line.getCoordinates().get(1));
    // WKT
    assertEquals("GEOMETRYCOLLECTION M (POINT (4.0 6.0 3.0), LINESTRING (4.0 6.0 2.0, 7.0 10.0 4.0))", gc.toString());
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
public static void main(final String... args)
{
    final JsonParser parser
        = Parboiled.createParser(JsonParser.class);

    final Scanner scanner = new Scanner(System.in);
    ParsingResult<?> result;
    String line;

    while (true) {
        System.out.print("Enter a value to test (empty to quit): ");
        line = scanner.nextLine();
        if (line.isEmpty())
            break;
        result = new ReportingParseRunner(parser.jsonText())
            .run(line);
        if (result.hasErrors()) {
            System.out.println("Invalid input!");
            System.out.println(ErrorUtils.printParseErrors(result));
        } else {
            System.out.println(ParseTreeUtils.printNodeTree(result));
        }
    }
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
@Test
public void threeDimensional() {
    WKTParser parser = Parboiled.createParser(WKTParser.class);
    ParsingResult<Geometry> result = new ReportingParseRunner(parser.WKT()).run("POINT Z (1 2 3)");
    Geometry geometry = result.resultValue;
    assertNotNull(geometry);
    assertTrue(geometry instanceof Point);
    Point point = (Point) geometry;
    assertEquals(Dimension.Three, point.getDimension());
    assertFalse(point.getCoordinate().isEmpty());
    assertTrue(point.getCoordinate().getDimension() == Dimension.Three);
    assertEquals(1, point.getCoordinate().getX(), 0.001);
    assertEquals(2, point.getCoordinate().getY(), 0.001);
    assertEquals(3, point.getCoordinate().getZ(), 0.001);
    assertTrue(Double.isNaN(point.getCoordinate().getM()));
    assertNull(point.getSrid());
    assertEquals("POINT Z (1.0 2.0 3.0)", point.toString());
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
public static List<Node> parse(String query, ParserConfig config) {
    QueryParser expressionParser = Parboiled.createParser(QueryParser.class, config);
    ValueStack<Object> nodes = parse(query, expressionParser.Query());
    List<Node> nodeList = new LinkedList<>();

    for (Object node : nodes) {
        if (node instanceof Node) {
            nodeList.add((Node) node);
        }
    }
    return nodeList;
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
private void testOrderOperation(String query, List<OrderNode.OrderSpecifier> expected) {
    QueryParser expressionParser = Parboiled.createParser(QueryParser.class);

    ValueStack<Object> nodes = ExpressionParserUtils.parse(query, expressionParser.Query());
    for (Object node : nodes) {
        if (node instanceof OrderNode) {
            assertOrders((OrderNode) node, expected);
            return;
        }
    }
    Assert.fail("Order node not found");
}
 

import org.parboiled.Parboiled; //导入方法依赖的package包/类
private void testProjectionOperation(String query, List<String> expected) {
    QueryParser expressionParser = Parboiled.createParser(QueryParser.class);

    ValueStack<Object> nodes = ExpressionParserUtils.parse(query, expressionParser.Query());
    for (Object node : nodes) {
        if (node instanceof ProjectionNode) {
            assertProjections((ProjectionNode) node, expected);
            return;
        }
    }
    Assert.fail("Projection node not found");
}