Comment faire correspondre une chaîne, mais indépendamment de la casse?

Question

Disons que je veux correspondre « bière », mais ne se soucient pas de la casse.

Actuellement, je suis en train de définir un jeton pour être ( 'b' | 'B' 'e' | 'E' 'e' | 'E' 'r' | 'R') mais j'ai beaucoup de tel don « t veulent vraiment gérer 'verilythisisaverylongtokenindeedomyyesitis'.

Le wiki antlr semble indiquer qu'il ne peut pas être fait (en antlr) ... mais je me demandais si quelqu'un avait quelques trucs intelligents ...

Answer 1

Comment définir au sujet d'un jeton de lexer pour chaque caractère d'identification admissible, puis construire le jeton d'analyseur comme une série de ceux?

beer: B E E R;

A : 'A'|'a';
B: 'B'|'b';

etc.

Answer 2

Je voudrais ajouter à la réponse acceptée: un ensemble prêt -fait se trouve à insensible à la casse des blocs de construction de antlr , et la partie pertinente inclus ci-dessous pour plus de commodité

fragment A:('a'|'A');
fragment B:('b'|'B');
fragment C:('c'|'C');
fragment D:('d'|'D');
fragment E:('e'|'E');
fragment F:('f'|'F');
fragment G:('g'|'G');
fragment H:('h'|'H');
fragment I:('i'|'I');
fragment J:('j'|'J');
fragment K:('k'|'K');
fragment L:('l'|'L');
fragment M:('m'|'M');
fragment N:('n'|'N');
fragment O:('o'|'O');
fragment P:('p'|'P');
fragment Q:('q'|'Q');
fragment R:('r'|'R');
fragment S:('s'|'S');
fragment T:('t'|'T');
fragment U:('u'|'U');
fragment V:('v'|'V');
fragment W:('w'|'W');
fragment X:('x'|'X');
fragment Y:('y'|'Y');
fragment Z:('z'|'Z');

Ainsi, un exemple est

   HELLOWORLD : H E L L O W O R L D;

Answer 3

Définir des jetons de la casse avec

BEER: [Bb] [Ee] [Ee] [Rr];

Answer 4

Nouvelle page de documentation est apparue dans repo ANTLR GitHub: Case-Insensible Lexing . Vous pouvez utiliser deux approches:

1. celui décrit dans la réponse de @ javadba
2. Vous pouvez également ajouter un flux de caractères à votre code, qui transformera un flux d'entrée pour abaisser ou majuscules. Des exemples pour les principales langues que vous pouvez trouver sur la même page de doc.

Mon avis, il est préférable d'utiliser la première approche et ont la grammaire qui décrit toutes les règles. Mais si vous utilisez la grammaire bien connue, par exemple de Grammars écrites pour ANTLR v4 , puis deuxième approche peut être plus approprié.

Answer 5

Une solution je en C #: utilisez le code ASCII pour passer à caractère plus petit cas

.

class CaseInsensitiveStream : Antlr4.Runtime.AntlrInputStream {
  public CaseInsensitiveStream(string sExpr)
     : base(sExpr) {
  }
  public override int La(int index) {
     if(index == 0) return 0;
     if(index < 0) index++;
     int pdx = p + index - 1;
     if(pdx < 0 || pdx >= n) return TokenConstants.Eof;
     var x1 = data[pdx];
     return (x1 >= 65 && x1 <= 90) ? (97 + x1 - 65) : x1;
  }
}