ANTLR 词法分析器排除字符串

Question

大家好

我正在尝试构建一个用于解析特定领域语言的词法分析器。 我有一组保留令牌（片段 RESERVED）和一个转义字符。每当出现未转义的保留标记时，词法分析器应该拆分。

一个简化的例子：

SEP: ';';
AND: '&&';

fragment ESCAPE: '/';    
fragment RESERVED: SEP | AND | ESCAPE;

SINGLETOKEN : (~(RESERVED) | (ESCAPE RESERVED))+;

问题：

只要 RESERVED 仅包含单个字符标记，它就可以正常工作。 否定操作 ~ 仅适用于单个字符。

不幸的是，我也需要它来处理字符串令牌。 所以标记超过 1 个字符（参见示例中的 AND）。有没有一种简单的方法可以做到这一点？ 我需要在没有内联 java 或 c 代码的情况下解决问题，因为它必须编译成不同的语言，我不想维护单独的副本。

希望有人能帮助我

---

整个脚本的示例输入

创建;假;假;1.key = bla; trig;true;false;(1.key1 ~ .*thisIsRegex || 2.oldKey1 €) && (1.bla=2.blub || 1.blub=bla);

在 Lexer 之后应该是这样的 |是令牌分隔符，空格不重要：|create|;|false|;|false|;|1.|key| = |白|;|触发|;|true|;|false|;|(|1.|key1| ~| .*thisIsRegex| || |2.|oldKey1| €|)| && |(|1.|bla|=|2.|blub| || |1.|blub|=|bla|)|;|

整个脚本可以在http://pastebin.com/Cz520VW4找到 （请注意此链接将在一个月后过期）它目前不适用于正则表达式部分。

---

可能但可怕的解决方案

我找到了一个可能的解决方案，但它确实很老套，并且使脚本更容易出错。所以我宁愿找更干净的东西。

我目前正在做的是手写否定（~RESERVED）。

SEP: ';';
AND: '&&';

fragment ESCAPE: '/';    
fragment RESERVED: SEP | AND | ESCAPE;

NOT_RESERVED:
   :  '&' ~('&' | SEP | ESCAPE)  
   // any two chars starting with '&' followed by a character other then a reserve character
   |  ~('&' | SEP | ESCAPE) ~(SEP | ESCAPE)   
   // other than reserved character followed by '&' followed by any char
   ;
SINGELTON : (NOT_RESERVED | (ESCAPE RESERVED))+;

真正的脚本有超过 5 个多字符标记，以后可能会有更多超过 2 个字符，所以这种解决问题的方法会变得相当复杂。

Answer 1

它目前不适用于正则表达式部分...

那是因为您已将正则表达式文字声明为几乎任何东西。如果正则表达式文字以保留标记开头，例如：1.key1 ~ falser？

简而言之，我不建议您按照您现在尝试的方式来实现您的词法分析器。相反，几乎所有编程语言都实现了正则表达式：让它们被分隔符（或带引号的字符串）封装：

1.key1 ~ /falser/

或：

1.key1 ~ "falser"

您可以在您的词法分析器中添加一个标志，每当遇到~ 时该标志就会翻转，并根据该标志创建一个正则表达式文字。这是一个关于如何做到这一点的小演示：

grammar TriggerDescription;

options {
  output=AST;
}

tokens {

 // seperator
 SEP = ';';

 // md identifier
 OLDMD   =        '1.';
 NEWMD   =        '2.';

 // boolean
 TRUE    =        'true';
 FALSE   =        'false';

//atoms
 EX     =       '€';
 EQ     =       '=';
 SMEQ   =       '<=';
 GREQ   =       '>=';
 GR     =       '>';
 SM     =       '<';

 // literals
 AND    =        '&&';
 OR     =        '||';
 NOT    =        '!';
 OPENP  =        '(';
 CLOSEP =        ')';

 // token identifier
 TRIGGER = 'TRIGGER';
 REPFLAG = 'REPFLAG';
 LOCALFLAG = 'LOCALFLAG';
 TRIGGERID = 'TRIGGERID';
 EVALUATOR = 'EVALUATOR';
 ROOT = 'ROOT';
}

@lexer::members {
  private boolean regexExpected = false;
}

parse
        : trigger+ EOF -> ^(ROOT trigger+)
          //(t=. {System.out.printf("\%-15s '\%s'\n", tokenNames[$t.type], $t.text);})* EOF
        ;

trigger
        : triggerid SEP repflag SEP exeflag SEP mdEval SEP -> ^(TRIGGER triggerid repflag exeflag mdEval)
        ;

triggerid
        : rs = WORD     -> ^(TRIGGERID[$rs])
        ;

repflag
        : rs = TRUE     -> ^(REPFLAG[$rs])
        | rs = FALSE    -> ^(REPFLAG[$rs])
        ;

exeflag
        : rs = TRUE     -> ^(LOCALFLAG[$rs])
        | rs = FALSE    -> ^(LOCALFLAG[$rs])
        ;

mdEval
        : orExp         -> ^(EVALUATOR orExp)
        ;

orExp
        :  andExp (OR^ andExp)* // Make `||` root
        ;

andExp
        :  notExp (AND^ notExp)* // Make `##` root
        ;

notExp
        :  (NOT^)*atom // Make `!` root
        ;

atom
        :       key EX^
        |       key MT^ REGEX
        |       key EQ^ (key | WORD)
        |       key GREQ^ (key | WORD)
        |       key SMEQ^ (key | WORD)
        |       key GR^ (key | WORD)
        |       key SM^ (key | WORD)
        |       OPENP orExp CLOSEP -> orExp // removing the parenthesis
        ;      

key     :       OLDMD rs = WORD -> ^(OLDMD[$rs])
        |       NEWMD rs = WORD -> ^(NEWMD[$rs])
        ;





/*------------------------------------------------------------------
 * LEXER RULES
 *------------------------------------------------------------------*/

// chars used for words might need to be extended
fragment CHAR  
        :       'a'..'z' | 'A'..'Z' | '0'..'9'
        ;

// chars used in regex
fragment REG_CHAR
        :       '|' | '[' | '\\' | '^' | '$' | '.' | '?' | '*' | '+' | '(' | ')'
        ;

fragment RESERVED
        :       SEP | ESCAPE | EQ
        ;

// white spaces taps etc
fragment WS
        :       '\t' | ' ' | '\r' | '\n'| '\u000C'
        ;

fragment ESCAPE
        :       '/'
        ;      

MT
        :       '~' {regexExpected = true;}
        ;

REGEX
@after{regexExpected = false;}
        :       {regexExpected}?=> WS* ~WS+
        ;

LINE_COMMENT
        :       '//' ~('\n'|'\r')* '\r'? '\n' {$channel=HIDDEN;}
        ;

WHITESPACE
        :       WS+    { $channel = HIDDEN; }
        ;

COMMENT
        :       '/*' .* '*/' {$channel=HIDDEN;}
        ;

WORD    :       CHAR+
        ;

这将为您发布的示例输入创建以下 AST：

但是，请意识到这只是一个快速演示。我现在定义REGEX 的方式是它会消耗它看到的任何非空格字符。换句话说，要结束REGEX，您必须在其后直接放置一个空格。调整我的示例以适合您自己的需要。

祝你好运！

附言。顺便说一句，REGEX 规则中奇怪的{ ... }?=> 语法被称为“门控语义谓词”。在此处了解更多信息：What is a 'semantic predicate' in ANTLR?