antlr v4 使用指南连载5——如何编写词法定义

如何编写词法定义#

       继上一篇文章，相信大家都明了编写词法规则的两个基本原则。那么接下来就可以开始编写词法文件了。对于计算机科学来说，很多词法规则是一致的。如标识符、数字等，它们都可以重复在多个项目中应用，这是题外话。

在词法文件中，除了词法定义之外，还有一些可选项，应该要先说明一下。匆匆一瞥，以览概貌，这是我一贯的风格。

1. fragment 词法片段，构成词法的元素，不是一个词法规则。在词法规则中可引用一个或多个词法片段。如：

    fragement
   
    	DIGIT : [0-9];
   
    INTEGER : DIGIT | [1-9] DIGIT+;
   
   

2. {action} 词法规则关联的目标语言代码。当输入串被词法规则匹配时，执行定义的action。如：

    fragement
   
    	DIGIT : [0-9];
   
    INTEGER : DIGIT | [1-9] DIGIT+ {System.out.println("match an integer.");};
   
   

3. mode 主要用于解决一个语法中包含一个或多个其他不同的语法。如Java语法的annotation（注解）。再比如XML文件，示例如下：

    lexer grammar XMLLexer;
   
    // Default "mode" : Everything OUTSIDE of a tag
   
    OPEN : '<' ->pushMode(INSIDE);
   
    COMMENT : '<!--'.*?'-->' ->skip;
   
    EntityRef : '&'[a-z]+';';
   
    TEXT : ~('<'|'&')+; //match any 16bit char minus < and &
   
    // -----------------Everything INSIDE of a tag---------------------
   
    mode INSIDE;
   
    CLOSE : '>' ->popMode;//back to default mode
   
    SLASH_CLOSE: '/>' ->popMode;
   
    EQUALS : '=';
   
    STRING : '"'.*?'"';
   
    SlashName : '/'Name;
   
    Name : ALPHA (ALPHA|DIGIT)*;
   
    S : [\t\r\n] ->skip;
   
    fragment
   
    	ALPHA : [a-zA-Z];
   
    fragment
   
    	DIGIT : [0-9];
   
   

4. hidden channel 将不需要关注的如注释、空格等发送到隐藏通道中。当然需要的时候还可以用antlr的api获取回来。如：

    COMMENT : '/*'.*?'*/' -> channel(HIDDEN); //match anything between /* and */
   
    WS : [\r\t\u000C\n]+ -> channel(HIDDEN);
   
   

       词法(lexer)文件中的所有内容已经清晰地介绍给大家了，下面正式进入词法规则编写。遵照antlr词法规则及惯例，在词法文件中，一般会将fragment、单字符定义、关键字定义放在最前面，而具体的词法（token）定义放在后面。

       除此之外，还有一个一开始可能就要考虑的问题，就是你所编写的目标语言对大小写是否敏感。在这里我推荐的写法如下：

1. 大小写敏感 对26个英文字母分别定义大写、小写两个词法规则。使用的时候大写地方就用大写的词法规则，小写就用小写的词法规则。

    fragment
   
    	A : [A];
   
    fragment
   
    	A_ : [a];
   
   

2. 大小写不敏感 对26个字母定义一个词法规则，包含大小写字母在里面。使用的时候，直接使用词法规则代替。

    fragment
   
    	A : [aA];
   
   

       由此可见，词法文件的开头应该就是根据是否大小敏感先把26个英文字母的词法规则确定。然后就是定义关键字及预定义字符。关键字就是目标语言的保留、非保留关键字。保留关键字是指只允许在语言规范定义的地方使用，不能在其他地方使用；非保留关键字是指可以使用，但不推荐使用。预定义字符是指诸如操作符(>, <, =, >>, >>>, >=, <=, ., ^, %, $, @, !, *, +, -等)。紧接着就可以定义其他fragment了，如DIGIT。fragment就是定义一些不需要被识别为独立token的字符，如0-9，定义一个fragment给其他词法规则引用，而0-9本身可以另外定义一个整数的词法规则来匹配。下面是sqlite的示例：

fragment DIGIT : [0-9];

fragment A : [aA];

fragment B : [bB];

fragment C : [cC];

fragment D : [dD];

fragment E : [eE];

fragment F : [fF];

fragment G : [gG];

fragment H : [hH];

fragment I : [iI];

fragment J : [jJ];

fragment K : [kK];

fragment L : [lL];

fragment M : [mM];

fragment N : [nN];

fragment O : [oO];

fragment P : [pP];

fragment Q : [qQ];

fragment R : [rR];

fragment S : [sS];

fragment T : [tT];

fragment U : [uU];

fragment V : [vV];

fragment W : [wW];

fragment X : [xX];

fragment Y : [yY];

fragment Z : [zZ];

SCOL : ';';

DOT : '.';

OPEN_PAR : '(';

CLOSE_PAR : ')';

COMMA : ',';

ASSIGN : '=';

STAR : '*';

PLUS : '+';

MINUS : '-';

TILDE : '~';

PIPE2 : '||';

DIV : '/';

MOD : '%';

LT2 : '<<';

GT2 : '>>';

AMP : '&';

PIPE : '|';

LT : '<';

LT_EQ : '<=';

GT : '>';

GT_EQ : '>=';

EQ : '==';

NOT_EQ1 : '!=';

NOT_EQ2 : '<>';

// http://www.sqlite.org/lang_keywords.html

K_ABORT : A B O R T;

K_ACTION : A C T I O N;

K_ADD : A D D;

K_AFTER : A F T E R;

K_ALL : A L L;

K_ALTER : A L T E R;

K_ANALYZE : A N A L Y Z E;

K_AND : A N D;

K_AS : A S;

K_ASC : A S C;

K_ATTACH : A T T A C H;

K_AUTOINCREMENT : A U T O I N C R E M E N T;

K_BEFORE : B E F O R E;

K_BEGIN : B E G I N;

K_BETWEEN : B E T W E E N;

K_BY : B Y;

K_CASCADE : C A S C A D E;

K_CASE : C A S E;

K_CAST : C A S T;

K_CHECK : C H E C K;

K_COLLATE : C O L L A T E;

K_COLUMN : C O L U M N;

K_COMMIT : C O M M I T;

K_CONFLICT : C O N F L I C T;

K_CONSTRAINT : C O N S T R A I N T;

K_CREATE : C R E A T E;

K_CROSS : C R O S S;

K_CURRENT_DATE : C U R R E N T '_' D A T E;

K_CURRENT_TIME : C U R R E N T '_' T I M E;

K_CURRENT_TIMESTAMP : C U R R E N T '_' T I M E S T A M P;

K_DATABASE : D A T A B A S E;

K_DEFAULT : D E F A U L T;

K_DEFERRABLE : D E F E R R A B L E;

K_DEFERRED : D E F E R R E D;

K_DELETE : D E L E T E;

K_DESC : D E S C;

K_DETACH : D E T A C H;

K_DISTINCT : D I S T I N C T;

K_DROP : D R O P;

K_EACH : E A C H;

K_ELSE : E L S E;

K_END : E N D;

K_ESCAPE : E S C A P E;

K_EXCEPT : E X C E P T;

K_EXCLUSIVE : E X C L U S I V E;

K_EXISTS : E X I S T S;

K_EXPLAIN : E X P L A I N;

K_FAIL : F A I L;

K_FOR : F O R;

K_FOREIGN : F O R E I G N;

K_FROM : F R O M;

K_FULL : F U L L;

K_GLOB : G L O B;

K_GROUP : G R O U P;

K_HAVING : H A V I N G;

K_IF : I F;

K_IGNORE : I G N O R E;

K_IMMEDIATE : I M M E D I A T E;

K_IN : I N;

K_INDEX : I N D E X;

K_INDEXED : I N D E X E D;

K_INITIALLY : I N I T I A L L Y;

K_INNER : I N N E R;

K_INSERT : I N S E R T;

K_INSTEAD : I N S T E A D;

K_INTERSECT : I N T E R S E C T;

K_INTO : I N T O;

K_IS : I S;

K_ISNULL : I S N U L L;

K_JOIN : J O I N;

K_KEY : K E Y;

K_LEFT : L E F T;

K_LIKE : L I K E;

K_LIMIT : L I M I T;

K_MATCH : M A T C H;

K_NATURAL : N A T U R A L;

K_NO : N O;

K_NOT : N O T;

K_NOTNULL : N O T N U L L;

K_NULL : N U L L;

K_OF : O F;

K_OFFSET : O F F S E T;

K_ON : O N;

K_OR : O R;

K_ORDER : O R D E R;

K_OUTER : O U T E R;

K_PLAN : P L A N;

K_PRAGMA : P R A G M A;

K_PRIMARY : P R I M A R Y;

K_QUERY : Q U E R Y;

K_RAISE : R A I S E;

K_RECURSIVE : R E C U R S I V E;

K_REFERENCES : R E F E R E N C E S;

K_REGEXP : R E G E X P;

K_REINDEX : R E I N D E X;

K_RELEASE : R E L E A S E;

K_RENAME : R E N A M E;

K_REPLACE : R E P L A C E;

K_RESTRICT : R E S T R I C T;

K_RIGHT : R I G H T;

K_ROLLBACK : R O L L B A C K;

K_ROW : R O W;

K_SAVEPOINT : S A V E P O I N T;

K_SELECT : S E L E C T;

K_SET : S E T;

K_TABLE : T A B L E;

K_TEMP : T E M P;

K_TEMPORARY : T E M P O R A R Y;

K_THEN : T H E N;

K_TO : T O;

K_TRANSACTION : T R A N S A C T I O N;

K_TRIGGER : T R I G G E R;

K_UNION : U N I O N;

K_UNIQUE : U N I Q U E;

K_UPDATE : U P D A T E;

K_USING : U S I N G;

K_VACUUM : V A C U U M;

K_VALUES : V A L U E S;

K_VIEW : V I E W;

K_VIRTUAL : V I R T U A L;

K_WHEN : W H E N;

K_WHERE : W H E R E;

K_WITH : W I T H;

K_WITHOUT : W I T H O U T;

IDENTIFIER

 : '"' (~'"' | '""')* '"'

 | '`' (~'`' | '``')* '`'

 | '[' ~']'* ']'

 | [a-zA-Z_] [a-zA-Z_0-9]* // TODO check: needs more chars in set

 ;

NUMERIC_LITERAL

 : DIGIT+ ( '.' DIGIT* )? ( E [-+]? DIGIT+ )?

 | '.' DIGIT+ ( E [-+]? DIGIT+ )?

 ;

 BIND_PARAMETER

 : '?' DIGIT*

 | [:@$] IDENTIFIER

 ;

STRING_LITERAL

 : '\'' ( ~'\'' | '\'\'' )* '\''

 ;

BLOB_LITERAL

 : X STRING_LITERAL

 ;

 SINGLE_LINE_COMMENT

 : '--' ~[\r\n]* -> channel(HIDDEN)

 ;

MULTILINE_COMMENT

 : '/*' .*? ( '*/' | EOF ) -> channel(HIDDEN)

 ;

 SPACES

 : [ \u000B\t\r\n] -> channel(HIDDEN)

 ;

       词法规则的写法就介绍到这里为止。

未完待续>>>