3

我计划在解析过程中包含文本元数据（如粗体、字体大小等）以实现更好的识别。

例如，我有一个给定的结构，其中单独一行的单词word/r/n是粗体且大小为24px，是某篇文章的标题。为了获得更好的识别结果，我想考虑字符以及元数据。就 ANTRL 而言，我不确定如何才能做到最好。我想做类似的事情：

  1. 将原始文本的每个字符包装到带有元数据字段的自定义对象中，并将其传递给 ANTLR。
  2. 预处理文本并在特定位置插入语法专家考虑的元数据注释。

我真的很喜欢选择选项1。但我不确定我需要从 ANTLR 中的哪个部分进行子类化等。我ANTLRInputStream-Object是否必须从解析器等。有没有更优雅的方式，尤其是在使用块中的动作解析时查询令牌？{}

如果有人有一些提示和/或经验，那就太好了！

编辑：

这是一个更具体的简单示例：我有一个文件，其中包含我正手解析的元数据的编码。包含换行符的实际文本如下所示：

entryOne
Here is some content one.
entryTwo
Here is some content two.

其中标题entryOne和entryTwo最初的字体大小为 24 像素，内容的字体大小为 12 像素（作为示例性给定值）。Char by char 我创建了一个自定义对象的新实例，将字符封装为String和font-size。

我用字体大小的字段为每个字符初始化各自的对象，例如，对于内容的第一个字母，entryOne就像 MyChar aTitelChar = new MyChar("e", 24); 第二行一样，Here is some content one.我创建 MyChar 的实例，例如：

MyChar aContentChar= new MyChar("H", 12);

文本的所有字符都包含在下面的实例中MyChar-类并添加到 aList<MyChar>以便为 ANTLR 生成新输入。

下面是字符的 Java 类：

public class MyChar {
    private int fontSizePx;
    private String text;

    public MyChar(String text, int fontSizePx) {
        this.text = text;
        this.fontSizePx = fontSizePx;
    }

    public int getFontSizePx() {
        return fontSizePx;
    }

    public String getText() {
        return text;
    }
}

我希望我的语法与上述两个条目相匹配（或以这种方式进行更多格式化），这两个条目又由一个标题和一个以句号结尾的内容组成。该语法可能如下所示：

rule: entry+ NEWLINE
;
entry:
title
content
;   
title: 
letters NEWLINE
;
content:
(letters)+ '.' NEWLINE
;
letters:
LETTERS 
;
LETTERS:
('a'..'z' | 'A'..'Z')+
;
WS:
(' ' | '\t' | 'f' ) + {$channel = HIDDEN;};
NEWLINE:'\r'? '\n';

现在，例如，我想做的是通过在-rule 返回之前检查包含标题标记的所有字母的字体大小来确定它是否真的是条目的标题。如果输入符合语法但实际上是某种错误（原始元数据编码的文件以符合-rule 但实际上是内容的内容开头），语法的作者可以在他知道的情况下对其进行排序标题的原始字体大小为 24 并检查。如果其中一个字母标记不等于font-size 24，则抛出异常/不返回/执行 smthg。合适的。titeltitle

我正在考虑的事情是在哪里插入List<MyChar>以提供此功能（在 ANTLR 的上下文中解析时查询各种元数据）。我正在尝试使用 ANTLR 的类，但由于我是 ANTLR 的新手，我想可能一些有经验的用户可以为我指出正确的方向，比如哪里是自定义对象的好插入点？我应该从实施CharStream和覆盖一些方法开始吗？可能有一些我还没有找到的 ANTLR 提供的东西？

4

1 回答 1

3

这是完成我认为您要实现的目标的一种方法，它使用解析器来管理与元数据的匹配输入。请注意，我使空格很重要，因为它是内容的一部分并且不能被跳过。我还将句点作为内容的一部分来简化示例，而不是将它们用作标记。

系统Ex.g

grammar SysEx;

@header {
    import java.util.List;
}

@parser::members {
        private List<MyChar> metadata;
        private int curpos;

        private boolean isTitleInput(String input) {
            return isFontSizeInput(input, 24);
        }

        private boolean isContentInput(String input){
            return isFontSizeInput(input, 12);
        }

        private boolean isFontSizeInput(String input, int fontSize){
            List<MyChar> sublist = metadata.subList(curpos, curpos + input.length());

            System.out.println(String.format("Testing metadata for input=\%s, font-size=\%d", input, fontSize));

            int start = curpos;            
            //move our metadata pointer forward.
            skipInput(input);

            for (int i = 0, count = input.length(); i < count; ++i){
                MyChar chardata = sublist.get(i);
                char c = input.charAt(i);
                if (chardata.getText().charAt(0) != c){
                    //This character doesn't match the metadata (ERROR!)
                    System.out.println(String.format("Content mismatch at metadata position \%d: metadata=(\%s,\%d); input=\%c", start + i, chardata.getText(), chardata.getFontSizePx(), c));
                    return false;
                } else if (chardata.getFontSizePx() != fontSize){
                    //The font is wrong.
                    System.out.println(String.format("Format mismatch at metadata position \%d: metadata=(\%s,\%d); input=\%c", start + i, chardata.getText(), chardata.getFontSizePx(), c));
                    return false;
                }
            }

            //All characters check out.
            return true;
        }

        private void skipInput(String str){
            curpos += str.length();
            System.out.println("\t\tMoving metadata pointer ahead by " + str.length() + " to " + curpos);
        }
}

rule[List<MyChar> metadata]
    @init {
        this.metadata = metadata;
    }
    : entry+ EOF
    ;
entry
    : title content
    {System.out.println("Finished reading entry.");}
    ;   
title
    : line {isTitleInput($line.text)}? newline {System.out.println("Finished reading title " + $line.text);}
    ;
content
    : line {isContentInput($line.text)}? newline {System.out.println("Finished reading content " + $line.text);}
    ;
newline
    : (NEWLINE{skipInput($NEWLINE.text);})+
    ;
line returns [String text]
    @init { 
        StringBuilder builder = new StringBuilder();
    }
    @after {
        $text = builder.toString();
    }
    : (ANY{builder.append($ANY.text);})+ 
    ;

NEWLINE:'\r'? '\n';
ANY: .; //whitespace can't be skipped because it's content.

Atitle是line与标题元数据（24 号字体）后跟一个或多个换行符的匹配项。

Acontent是line匹配内容元数据（12 号字体）后跟一个或多个换行符的 a。如上所述，为了简化，我删除了一段时间的检查。

Aline是不包括换行符的字符序列。

验证语义谓词（{...}?after ）用于line验证该行是否与元数据匹配。

这是我用来测试语法的代码（为简洁起见，减去导入）：

SysExGrammar.java

public class SysExGrammar {
    public static void main(String[] args) throws Exception {
        //Create some metadata that matches our input.
        List<MyChar> matchingMetadata = new ArrayList<MyChar>();
        appendMetadata(matchingMetadata, "entryOne\r\n", 24);
        appendMetadata(matchingMetadata, "Here is some content one.\r\n", 12);
        appendMetadata(matchingMetadata, "entryTwo\r\n", 24);
        appendMetadata(matchingMetadata, "Here is some content two.\r\n", 12);

        parseInput(matchingMetadata);

        System.out.println("Finished example #1");


        //Create some metadata that doesn't match our input (negative test).
        List<MyChar> mismatchingMetadata = new ArrayList<MyChar>();
        appendMetadata(mismatchingMetadata, "entryOne\r\n", 24);
        appendMetadata(mismatchingMetadata, "Here is some content one.\r\n", 12);
        appendMetadata(mismatchingMetadata, "entryTwo\r\n", 12); //content font size!
        appendMetadata(mismatchingMetadata, "Here is some content two.\r\n", 12);

        parseInput(mismatchingMetadata);

        System.out.println("Finished example #2");
    }

    private static void parseInput(List<MyChar> metadata) throws Exception {
        //Test setup
        InputStream resource = SysExGrammar.class.getResourceAsStream("SysExTest.txt");

        CharStream input = new ANTLRInputStream(resource);

        resource.close();

        SysExLexer lexer = new SysExLexer(input);
        CommonTokenStream tokens = new CommonTokenStream(lexer);

        SysExParser parser = new SysExParser(tokens);
        parser.rule(metadata);

        System.out.println("Parsing encountered " + parser.getNumberOfSyntaxErrors() + " syntax errors");
    }

    private static void appendMetadata(List<MyChar> metadata, String string,
            int fontSize) {

        for (int i = 0, count = string.length(); i < count; ++i){
            metadata.add(new MyChar(string.charAt(i) + "", fontSize));
        }
    }
}

SysExTest.txt（注意这使用 Windows 换行符 ( \r\n)

entryOne
Here is some content one.
entryTwo
Here is some content two.

测试输出（修剪；第二个示例有故意不匹配的元数据）：

Parsing encountered 0 syntax errors
Finished example #1
Parsing encountered 2 syntax errors
Finished example #2

此解决方案要求每个MyChar对应于输入中的一个字符（包括换行符，尽管您可以根据需要删除该限制——如果我还没有写下这个答案，我会删除它；））。

如您所见，可以将元数据绑定到解析器，并且一切都按预期工作。我希望这有帮助。

于 2012-11-26T00:53:13.657 回答