Hej everyone

Question

Hej everyone

我正在尝试构建一个用于解析特定于域的语言的词法分析器。我有一组保留令牌（片段RESERVED）和一个转义字符。每当保留令牌显示未转义时，词法分析器就会分开。

简化示例：

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

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

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

问题：

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

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

我希望有人可以帮助我

来自整个脚本的示例输入

create; false; false; 1.key = bla; trig; true; false;（1.key1~。* thisIsRegex || 2.oldKey1€）＆amp;＆amp; （1.bla = 2.blub || 1.blub = bla）;

Lexer之后应该看起来像这样令牌分隔符空格并不重要：| create |; | false |; | false |; | 1. | key | = | bla |; | trig |; | 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个字符，所以这种解决问题的方法会变得相当复杂。

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：

enter image description here

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

祝你好运！

PS。顺便说一句，{ ... }?=>规则中的奇怪REGEX语法称为＆＃34;门控语义谓词＆＃34; 。请在此处详细了解：What is a 'semantic predicate' in ANTLR?

ANTLR lexer排除字符串

Hej everyone

简化示例：

问题：

来自整个脚本的示例输入

可能但可怕的解决方案

1 个答案: