Aller au contenu principal

Référence de la grammaire

Référence complète de la grammaire ANTLR pour Raml, organisée par catégorie. Source : source/Raml.g4.


Aperçu​

Cette page contient la grammaire ANTLR complète sous forme brute. Chaque section montre les règles complètes de l'analyseur et de l'analyseur lexical pour une fonctionnalité particulière du langage.

Comment lire la syntaxe ANTLR :

NotationSignification
rule : ... ;Définition d'une règle d'analyseur
TOKEN : ... ;Définition d'un token d'analyseur lexical
|Alternative (OU)
?Optionnel (0 ou 1)
*Zéro ou plus
+Un ou plus
{ ... }?Prédicat sémantique (condition runtime)
-> skipIgnorer le token dans l'analyseur lexical

Pour un aperçu de plus haut niveau de la structure de la grammaire, voir Aperçu de la grammaire.


Programme et instructions​

La structure de plus haut niveau. Chaque programme est une séquence d'instructions.

program
: statement* EOF
;

statement
: sectionLabel
| jumpStmt
| typeDecl
| functionDecl
| methodDecl
| methodCallStmt
| printStmt
| assignment
| varDecl
| functionCallStmt
| ifStmt
| switchStmt
| whileStmt
| tryFailStmt
| breakStmt
| continueStmt
| ternaryStmt
| paramDecl
| rangeFieldCheck
| expr
| SEMI
;

Labels de section et sauts​

Les labels s'écrivent :nom: et peuvent inclure un nombre (ex. :phase1:). jump transfère le contrôle à un label.

sectionLabel
: ':' labelName ':' block? # sectionDecl
;

jumpStmt
: JUMP ':' labelName ':' # jumpSection
;

labelName
: ID INTEGER?
;

Déclarations d'objets​

Les objets sont déclarés avec nom: suivi d'un bloc indenté de champs et d'une section functions:.

typeDecl
: ID COLON structBlock # structDecl
;

structBlock
: INDENT structItemOrSemi+ DEDENT
;

structItemOrSemi
: structItem
| SEMI
;

structItem
: fieldDecl
| functionsBlock
;

Déclarations de champs​

Les champs supportent plusieurs styles de déclaration :

  • Groupé : flags code
  • Typé : flags bs
  • Deux-points : flags: bs
  • Objet imbriqué (indenté) : meta:\n flags
  • Objet imbriqué (en ligne) : meta: flags code
fieldDecl
: fieldSpec fieldSpec* NL? # fieldDeclList
;

fieldSpec
: typeSpec nameList # fieldTypeGroup
| ID typeSpec # fieldNameTyped
| ID COLON typeSpec # fieldNameColon
| ID COLON indentedNestedStruct # fieldNestedIndented
| ID COLON inlineNestedStruct # fieldNestedInline
;

nameList
: ID ID*
;

typeSpec
: bsType
| ID // référence de type nommé (bs, noms de structs, etc.)
| typeSpec '#'
;

Objets imbriqués​

indentedNestedStruct
: INDENT nestedFieldOrSemi+ DEDENT
;

nestedFieldOrSemi
: nestedField
| SEMI
;

nestedField
: fieldDecl
;

inlineNestedStruct
: fieldDecl fieldDecl* NL?
;

Types de bits​

bsType
: BS
;

Fonctions et méthodes​

Les fonctions sont déclarées dans le bloc functions: d'un objet. Les méthodes externes utilisent la syntaxe typeName:methodName:.

functionDecl
: ID COLON functionBlock # functionDefinition
;

functionBlock
: INDENT paramDecl statement* DEDENT
;

methodDecl
: typeName=ID COLON methodName COLON block # methodDefinition
;

methodName
: ID
;

paramDecl
: IN COLON paramSpecList?
;

paramSpecList
: paramSpec paramSpec*
;

paramSpec
: bsType ID
| ID
;

Éléments de fonction (dans le bloc functions:)​

functionItem
: methodName # functionDeclOnly
| methodName COLON block # functionDefBlock
| methodName COLON inlineStatement # functionDefInline
;

functionItemOrSemi
: functionItem
| SEMI
;

functionsBlock
: FUNCTIONS COLON INDENT functionItemOrSemi+ DEDENT
;

Instructions en ligne (corps de fonction sur une ligne)​

inlineStatement
: assignment
| methodCallStmt
| functionCallStmt
| printStmt
| expr
;

Variables et affectations​

Trois formes de déclaration de variable : type en tête, type deux-points, et inféré.

varDecl
: typeSpec nameList ASSIGN expr # varDeclTypedLeading
| typeSpec nameList # varDeclTypedNoInit
| ID COLON typeSpec ASSIGN expr # varDeclTyped
| ID COLON typeSpec # varDeclTypedNoInitColon
| ID COLON expr # varDeclInferred
;

assignment
: accessChain ASSIGN expr # assignNormal
| accessChain ADDR_ASSIGN expr # assignADDR
| accessChain compoundOp expr # assignCompound
| COLON nameList COLON ASSIGN expr # assignMultiField
;

compoundOp
: '+=' | '-=' | '*=' | '/=' | '%='
| '&=' | '|=' | '^=' | '<<=' | '>>='
| '+#=' // incrément de bits
;

Accès dynamique aux champs​

L'accès dynamique aux champs permet d'accéder à un champ d'objet ou une variable globale dont le nom est déterminé à l'exécution.

primaryAccess
: ID # primaryAccessId
| ID COLON INTEGER COLON # dynamicFieldAccess
| ID COLON simpleExprItem COLON { self._input.LA(1) != self.ID and self._input.LA(1) != self.COLON }? # dynamicFieldAccessExpr
| ADDR accessChain # primaryAccessAddr
;

Prédicat sémantique : La règle dynamicFieldAccessExpr utilise un prédicat pour éviter l'ambiguïté avec l'accès de style c:next:. Le prédicat vérifie que le token suivant n'est pas un ID ou COLON, garantissant que c:next: est analysé comme un accès de champ, pas un accès dynamique.

Vérification de plage de champs​

Itère sur une plage de champs numérotés et génère des conditions chaînées avec ||.

rangeFieldCheck
: ID COLON expr DOTDOT expr COLON cmpOp expr COLON block
;

cmpOp
: '<' | '>' | '<=' | '>=' | '==' | '!='
;

Exemple : c:1..9: == 0: génère if (c1 == 0 || c2 == 0 || ... || c9 == 0).

Flux de contrôle​

If / Orif / Else​

ifStmt
: IF expr COLON block (ORIF expr COLON block)* (ELSE COLON block)? # ifWithBlock
;

Switch / Switchloop​

switchStmt
: SWITCH expr COLON switchBlock # switchWithBlock
| SWITCHLOOP expr COLON switchBlock # switchLoopWithBlock
;

switchBlock
: INDENT switchClause+ DEDENT
;

switchClause
: caseClause
| defaultClause
;

caseClause
: CASE? expr COLON block
;

defaultClause
: DEFAULT COLON block
;

breakStmt
: BREAK
;

continueStmt
: CONTINUE
;

While​

whileStmt
: WHILE expr COLON block
;

Ternaire​

ternaryStmt
: expr '?' inlineStatement ':' inlineStatement
;

Try / Catch / End​

tryFailStmt
: TRY COLON block (FAIL | CATCH) COLON block (END COLON block)?
;

Expressions — Complètes (expr)​

La règle d'expression de niveau supérieur avec tous les opérateurs.

expr
: literal # literalExpr
| ARROW receiver ':' ID exprListPipe # methodCallExpr
| ARROW receiver ':' ID exprList # methodCallExprArgs
| ARROW receiver ':' ID # methodCallExprNoArgs
| ID exprList # functionCallExpr
| accessChain # refOrAddrExpr
| expr '++' # postIncrementExpr
| expr '--' # postDecrementExpr
| expr op=('*' | '/' | '%') expr # mulDivExpr
| expr op=('+' | '-') expr # addSubExpr
| expr op=('<<' | '>>') expr # shiftExpr
| expr op=('<' | '>' | '<=' | '>=' | '==' | '!=' | '=#=') expr # cmpExpr
| expr op='&' expr # bitwiseAndExpr
| expr op='^' expr # bitwiseXorExpr
| expr op='|' expr # bitwiseOrExpr
| expr '&&' expr # logicalAndExpr
| expr '||' expr # logicalOrExpr
| DBL_COLON expr DBL_COLON # doubleColonExpr
| '++' expr # preIncrementExpr
| '--' expr # preDecrementExpr
| '~' expr # bitwiseNotExpr
| AT expr # addressExpr
;

Précédence (de la plus basse à la plus haute)​

  1. OU logique ||
  2. ET logique &&
  3. OU bitwise |
  4. XOR bitwise ^
  5. ET bitwise &
  6. Comparaisons < > <= >= == != =#=
  7. Décalage << >>
  8. Additif + -
  9. Multiplicatif * / %
  10. Postfixe ++ --
  11. Préfixe ++ -- ~ @
  12. Groupement double-colon :: ::

Expressions — Éléments (exprItem)​

Mêmes opérateurs que expr, structurés en éléments. Utilisé dans les instructions print et les expressions pipe.

exprItem
: literal # literalItem
| ARROW receiver ':' ID exprListPipe # methodCallItem
| ARROW receiver ':' ID exprList # methodCallArgsItem
| ARROW receiver ':' ID # methodCallNoArgsItem
| accessChain # refOrAddrItem
| exprItem '++' # postIncrementItem
| exprItem '--' # postDecrementItem
| exprItem op=('*' | '/' | '%') exprItem # mulDivItem
| exprItem op=('+' | '-') exprItem # addSubItem
| exprItem op=('<<' | '>>') exprItem # shiftItem
| exprItem op=('<' | '>' | '<=' | '>=' | '==' | '!=' | '=#=') exprItem # cmpItem
| exprItem op='&' exprItem # bitwiseAndItem
| exprItem op='^' exprItem # bitwiseXorItem
| exprItem op='|' exprItem # bitwiseOrItem
| exprItem '&&' exprItem # logicalAndItem
| exprItem '||' exprItem # logicalOrItem
| DBL_COLON expr DBL_COLON # doubleColonItem
| '++' exprItem # preIncrementItem
| '--' exprItem # preDecrementItem
| '~' exprItem # bitwiseNotItem
| AT exprItem # addressItem
;

Expressions — Simples (simpleExprItem)​

Sous-ensemble restreint excluant les comparaisons et opérateurs logiques. Utilisé dans les arguments d'appels de méthodes/fonctions.

simpleExprItem
: literal # simpleLiteralItem
| ARROW receiver ':' ID exprListPipe # simpleMethodCallItem
| ARROW receiver ':' ID exprList # simpleMethodCallArgsItem
| ARROW receiver ':' ID # simpleMethodCallNoArgs
| accessChain # simpleRefOrAddrItem
| simpleExprItem '++' # simplePostIncrementItem
| simpleExprItem '--' # simplePostDecrementItem
| simpleExprItem op=('*' | '/' | '%') simpleExprItem # simpleMulDivItem
| simpleExprItem op=('+' | '-') simpleExprItem # simpleAddSubItem
| simpleExprItem op=('<<' | '>>') simpleExprItem # simpleShiftItem
| simpleExprItem op='&' simpleExprItem # simpleBitwiseAndItem
| simpleExprItem op='^' simpleExprItem # simpleBitwiseXorItem
| simpleExprItem op='|' simpleExprItem # simpleBitwiseOrItem
| DBL_COLON expr DBL_COLON # simpleDoubleColonItem
| '++' simpleExprItem # simplePreIncrementItem
| '--' simpleExprItem # simplePreDecrementItem
| '~' simpleExprItem # simpleBitwiseNotItem
| AT simpleExprItem # simpleAddressItem
;

Exclus à ce niveau : cmpItem, logicalAndItem, logicalOrItem (comparaisons et opérateurs logiques).

Chaînes d'accès et récepteurs​

Les chaînes d'accès supportent l'accès aux champs imbriqués via : (ex. pkt:meta:flags).

receiver
: AT? primaryAccess (':' ID)*
;

accessChain
: primaryAccess
| accessChain ':' ID
| AT primaryAccess
;

primaryAccess
: ID # primaryAccessId
| ID COLON INTEGER COLON # dynamicFieldAccess
| ID COLON simpleExprItem COLON { self._input.LA(1) != self.ID and self._input.LA(1) != self.COLON }? # dynamicFieldAccessExpr
| ADDR accessChain # primaryAccessAddr
;

Appels de méthodes et fonctions​

Les appels de méthodes utilisent le préfixe -> pour se distinguer de l'accès aux champs.

methodCallStmt
: ARROW receiver ':' ID { self._input.LA(1) != self.ASSIGN and self._input.LA(1) != self.COLON }? exprList
| ARROW receiver ':' ID { self._input.LA(1) != self.ASSIGN and self._input.LA(1) != self.COLON }?
;

functionCallStmt
: ID exprList
;

exprList
: simpleExprItem simpleExprItem*
;

exprListPipe
: PIPE INDENT expr expr* DEDENT
;

Instructions print​

printStmt
: PRINT printItem printItem* # printAlt
;

printItem
: expr
;

Littéraux​

literal
: INTEGER
| STRING
| ASSIGN
;

Mots-clés (Tokens de l'analyseur lexical)​

Les mots-clés sont définis comme des tokens de l'analyseur lexical, garantissant leur priorité sur les identifiants :

IF : 'if' ;
ORIF : 'orif' ;
ELSE : 'else' ;
SWITCH : 'switch' ;
SWITCHLOOP : 'switchloop' ;
CASE : 'case' ;
DEFAULT : 'default' ;
BREAK : 'break' ;
CONTINUE : 'continue' ;
WHILE : 'while' ;
TRY : 'try' ;
FAIL : 'fail' ;
CATCH : 'catch' ;
END : 'end' ;
JUMP : 'jump' ;
FUNCTIONS : 'functions' ;
IN : 'in' ;
BS : 'bs' ;
PRINT : 'print' ;

Tokens d'opérateurs​

ADDR_EQ : '=#=' ;
ADDR_ASSIGN : '#=' ;
ADDR : '#' ;
ID : [\p{L}_][\p{L}\p{N}_]* ;
INTEGER : [0-9]+ | '0x' [0-9a-fA-F]+ | '0b' [01]+ ;
STRING : TRIPLE_DQUOTE ( '\\' . | . )*? TRIPLE_DQUOTE
| TRIPLE_SQUOTE ( '\\' . | . )*? TRIPLE_SQUOTE
| '"' (~["\\\r\n] | '\\' .)* '"'
| '\'' (~['\\\r\n] | '\\' .)* '\''
;

fragment TRIPLE_DQUOTE : '"""' ;
fragment TRIPLE_SQUOTE : SQUOTE SQUOTE SQUOTE ;
fragment SQUOTE : '\'' ;

ASSIGN : '=' ;
DOTDOT : '..' ;
DBL_COLON : '::' ;
ARROW : '->' ;
COLON : ':' ;
PIPE : '|' ;
SEMI : ';' ;
AT : '@' ;

WS : [ \t]+ -> skip ;
BLOCK_COMMENT : '/*' .*? '*/' -> skip ;
COMMENT : '//' ~[\r\n]* -> skip ;
ELIPSE_COMMENT : '…' [ \t]+ ~[\r\n]* -> skip ;

NL : '\r\n' | '\n' | '\r' ;

Plongée Technique​

Désambiguïsation des tokens​

ANTLR résout les ambiguïtés de tokens en utilisant la priorité suivante :

  1. Correspondance la plus longue : La règle d'analyseur lexical qui consomme le plus de caractères gagne.
  2. Ordre des règles : Quand deux règles correspondent à la même longueur, celle définie en premier dans la grammaire gagne.

Cela signifie que les mots-clés (définis en premier) ont toujours priorité sur les identifiants (ID est défini après tous les mots-clés), et les opérateurs multi-caractères comme ADDR_EQ (=#=) sont appariés avant les opérateurs à un seul caractère (ASSIGN =, ADDR #).

Règles d'analyse lexicale des chaînes​

Les littéraux de chaîne utilisent la correspondance non gourmande (*?) pour gérer les séquences d'échappement :

STRING : TRIPLE_DQUOTE ( '\\' . | . )*? TRIPLE_DQUOTE

L'alternative '\\' . consomme une séquence d'échappement (antislash + n'importe quel caractère). L'alternative . consomme un caractère régulier. Le *? (non gourmand) garantit que la correspondance s'arrête au délimiteur de fermeture.

Fichiers générés​

L'exécution d'ANTLR sur Raml.g4 produit quatre fichiers :

FichierObjectif
RamlLexer.pyAnalyseur lexical — convertit le texte source en flux de tokens
RamlParser.pyAnalyseur — construit l'arbre d'analyse à partir du flux de tokens
RamlVisitor.pyVisiteur — classe de base abstraite pour le parcours AST
RamlListener.pyÉcouteur — classe de base abstraite pour l'analyse événementielle

Le pattern visiteur est utilisé à la fois par l'interpréteur et le générateur de code du compilateur pour parcourir l'arbre d'analyse et produire la sortie.