3

大家好

我正在尝试构建一个用于解析特定领域语言的词法分析器。我有一组保留令牌（片段 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上找到 （注意这个链接会在一个月内过期）它目前不适用于正则表达式部分。

可能但可怕的解决方案

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

我目前正在做的是手写否定（~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 个字符，所以这种解决问题的方法会变得相当复杂。

4

1 回答 1

2

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

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

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

1.key1 ~ /falser/

或者：

1.key1 ~ "falser"

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

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是它将消耗它看到的任何非空格字符。换句话说，要结束 a REGEX，您必须在其后直接放置一个空格。调整我的示例以适合您自己的需要。

祝你好运！

PS。顺便说一句，规则中的奇怪{ ... }?=>语法REGEX称为“门控语义谓词”。在此处了解更多信息：ANTLR 中的“语义谓词”是什么？

于 2012-08-20T10:04:03.867 回答