3

我正在研究的语言允许将某些标记粘在一起（例如“intfloat”），我正在寻找一种方法让词法分析器不将它们转换为 ID，以便它们在解析时单独可用。我能想到的最简单的语法是（省略 WS）：

B: 'B';
C: 'C';
ID: ('a'..'z')+;
doc : (B | C | ID)* EOF;

对抗：

bc
abc
bcd

我想从词法分析器中得到什么：

B C
ID (starts with not-a-keyword so it's an ID)
<error> (cannot concat non-keywords)

但正如预期的那样，我得到的是 3 个 ID。

我一直在考虑使 ID 不贪心，但会退化为每个字符的单独标记。我想我可以稍后将它们粘在一起，但感觉应该有更好的方法。

有什么想法吗？

谢谢

4

2 回答 2

2

这是一个解决方案的开始，使用词法分析器将文本分解为标记。这里的诀窍是规则ID可以在每次调用时发出多个令牌。这是非标准的词法分析器行为，因此有一些警告：

  • 我相信这在 ANTLR4 中不起作用。

  • 此代码假定所有令牌都排队进入tokenQueue.

  • RuleID不会阻止关键字重复，因此intintint会生成 tokens INT INT INT。如果这很糟糕，您将需要在词法分析器或解析器端处理它，这取决于您的语法中哪个更有意义。

  • 关键字越短，这个解决方案就越脆弱。输入internal无效ID，因为它以关键字开头，int但后跟非关键字字符串。

  • 语法会产生我没有删除的警告。如果您使用此代码，我建议您尝试删除它们。

这是语法：

多令牌.g

grammar MultiToken;


@lexer::members{
    private java.util.LinkedList<Token> tokenQueue = new java.util.LinkedList<Token>();

    @Override
    public Token nextToken() {
            Token t = super.nextToken();
            if (tokenQueue.isEmpty()){
                if (t.getType() == Token.EOF){
                    return t;
                } else { 
                    throw new IllegalStateException("All tokens must be queued!");
                }
            } else { 
                return tokenQueue.removeFirst();
            }
    }

    public void emit(int ttype, int tokenIndex) {
        //This is lifted from ANTLR's Lexer class, 
        //but modified to handle queueing and multiple tokens per rule.
        Token t;

        if (tokenIndex > 0){
            CommonToken last = (CommonToken) tokenQueue.getLast();
            t = new CommonToken(input, ttype, state.channel, last.getStopIndex() + 1, getCharIndex() - 1);
        } else { 
            t = new CommonToken(input, ttype, state.channel, state.tokenStartCharIndex, getCharIndex() - 1);
        }

        t.setLine(state.tokenStartLine);
        t.setText(state.text);
        t.setCharPositionInLine(state.tokenStartCharPositionInLine);
        emit(t);
    }

    @Override
    public void emit(Token t){
        super.emit(t);
        tokenQueue.addLast(t);
    }
}

doc     : (INT | FLOAT | ID | NUMBER)* EOF;

fragment
INT     : 'int';

fragment
FLOAT   : 'float';

NUMBER  : ('0'..'9')+;

ID  
@init {
    int index = 0; 
    boolean rawId = false;
    boolean keyword = false;
}
        : ({!rawId}? INT {emit(INT, index++); keyword = true;}
            | {!rawId}? FLOAT {emit(FLOAT, index++); keyword = true;}
            | {!keyword}? ('a'..'z')+ {emit(ID, index++); rawId = true;} 
          )+
        ;

WS      : (' '|'\t'|'\f'|'\r'|'\n')+ {skip();};

测试用例 1：混合关键字

输入

intfloat a
int b
float c
intfloatintfloat d

输出（代币）

[INT : int] [FLOAT : float] [ID : a] 
[INT : int] [ID : b]
[FLOAT : float] [ID : c] 
[INT : int] [FLOAT : float] [INT : int] [FLOAT : float] [ID : d]

测试用例 2：包含关键字的 ID

输入

aintfloat
bint
cfloat
dintfloatintfloat

输出（代币）

[ID : aintfloat] 
[ID : bint] 
[ID : cfloat] 
[ID : dintfloatintfloat]

测试用例 3：错误 ID #1

输入

internal

输出（令牌和词法分析器错误）

[INT : int] [ID : rnal] 
line 1:3 rule ID failed predicate: {!keyword}?

测试用例 4：错误 ID #2

输入 

floatation

输出（令牌和词法分析器错误） 

[FLOAT : float] [ID : tion] 
line 1:5 rule ID failed predicate: {!keyword}?

测试用例 5：非 ID 规则

输入

int x
float 3 float 4 float 5
5 a 6 b 7 int 8 d

输出（代币）

[INT : int] [ID : x] 
[FLOAT : float] [NUMBER : 3] [FLOAT : float] [NUMBER : 4] [FLOAT : float] [NUMBER : 5] 
[NUMBER : 5] [ID : a] [NUMBER : 6] [ID : b] [NUMBER : 7] [INT : int] [NUMBER : 8] [ID : d]
于 2013-01-09T07:33:21.157 回答
1

这是 ANTLR 4 的几乎所有语法的解决方案（只需要目标语言中的一个小谓词）：

lexer grammar PackedKeywords;

INT : 'int' -> pushMode(Keywords);
FLOAT : 'float' -> pushMode(Keywords);

fragment ID_CHAR : [a-z];
ID_START : ID_CHAR {Character.isLetter(_input.LA(1))}? -> more, pushMode(Identifier);
ID : ID_CHAR;

// these are the other tokens in the grammar
WS : [ \t]+ -> channel(HIDDEN);
Newline : '\r' '\n'? | '\n' -> channel(HIDDEN);

// The Keywords mode duplicates the default mode, except it replaces ID
// with InvalidKeyword. You can handle InvalidKeyword tokens in whatever way
// suits you best.
mode Keywords;

    Keywords_INT : INT -> type(INT);
    Keywords_FLOAT : FLOAT -> type(FLOAT);
    InvalidKeyword : ID_CHAR;
    // must include every token which can follow the Keywords mode
    Keywords_WS : WS -> type(WS), channel(HIDDEN), popMode;
    Keywords_Newline : Newline -> type(Newline), channel(HIDDEN), popMode;

// The Identifier mode is only entered if we know the current token is an
// identifier with >1 characters and which doesn't start with a keyword. This is
// essentially the default mode without keywords.
mode Identifier;

    Identifier_ID : ID_CHAR+ -> type(ID);
    // must include every token which can follow the Identifiers mode
    Identifier_WS : WS -> type(WS), channel(HIDDEN), popMode;
    Identifier_Newline : Newline -> type(Newline), channel(HIDDEN), popMode;

此语法也适用于 ANTLRWorks 2 词法分析器解释器（即将推出！），适用于除单字符标识符之外的所有内容。由于词法分析器解释器无法评估 in 中的谓词，因此（在解释器中）ID_START这样的输入将在通道上生成一个带有文本类型的单个标记。a<space>a<space>WSHIDDEN

于 2013-01-09T17:12:13.000 回答