Aller au contenu principal

Aperçu de la grammaire

Raml utilise une grammaire ANTLR 4 avec un analyseur lexical personnalisé sensible à l'indentation. Cette page décrit la structure de haut niveau de la grammaire du langage.


Aperçu​

Chaque programme Raml est une séquence d'instructions :

program → statement* EOF

Les programmes commencent généralement l'exécution au label :start:, bien que tout label puisse être ciblé par jump.

Types d'instructions en un coup d'œil​

CatégorieInstructionsDescription
Structurelabel de section, sautLabels (:name:) et transfert de contrôle
Déclarationstype (objet), fonction, méthode, variableDéfinir types, fonctions, méthodes, variables
Flux de contrôleif/orif/else, while, switch/switchloop, try/catch/endConditionnels, boucles, branchement, erreurs
Bouclesbreak, continueContrôle de boucle
Expressionsaffectation, ternaire, appel méthode, appel fonction, printCalcul et sortie
Opérations sur champsaffectation multi-champs, vérification de plageManipulation de champs d'objets

Mots-clés​

CatégorieMots-clés
Flux de contrôleif, orif, else, while, break, continue
Branchementswitch, switchloop, case, default
Gestion d'erreurstry, catch, end
Sautjump
Typesbs
Fonctionsfunctions, in
E/Sprint

Tous les mots-clés sont réservés et ne peuvent pas être utilisés comme identifiants. Tous les mots-clés peuvent être localisés via des fichiers keywords.raml.lang.

Blocs et indentation​

Les blocs sont définis par l'indentation :

block → INDENT statement+ DEDENT
  • Un deux-points : suivi d'un saut de ligne et d'une indentation accrue commence un bloc.
  • Une indentation réduite termine le bloc courant.
  • Les points-virgules ; sont optionnels et principalement utiles pour les instructions sur une ligne.

Plongée Technique​

Cette section couvre les détails d'implémentation de la grammaire — analyseur lexical, structure de l'analyseur, gestion des tokens, et fondement de conception.

Niveaux d'expressions​

Raml possède trois niveaux d'expressions imbriqués, chacun autorisant un ensemble différent d'opérateurs. Cette conception en niveaux empêche l'ambiguïté d'analyse dans les arguments d'appels de méthodes.

Niveau 1 : expr (Expressions complètes)​

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

  • Arithmétiques, bitwise, shift
  • Comparaisons (==, !=, <, >, <=, >=, =#=)
  • Logiques (&&, ||)
  • Appels de méthodes (->recv:method), appels de fonctions, chaînes d'accès
  • Incrément/décrément préfixe, address-of, NOT bitwise
  • Groupement double-colon (::expr::)

Utilisé dans : affectations, conditions, boucles while, conditions ternaires, expressions autonomes.

Niveau 2 : exprItem (Éléments d'expression)​

Identique à expr mais structuré en éléments dans des expressions plus grandes. Inclut comparaisons et opérateurs logiques.

Utilisé dans : instructions print, listes d'expressions pipe.

Niveau 3 : simpleExprItem (Expressions restreintes)​

Un sous-ensemble restreint qui exclut les opérateurs de comparaison et logiques :

  • Autorisés : littéraux, variables, chaînes d'accès, arithmétique, bitwise, shift, groupement double-colon, opérateurs préfixe/postfixe
  • Exclus : ==, !=, <, >, <=, >=, =#=, &&, ||

Utilisé dans : arguments d'appels de méthodes et fonctions, arguments make.

Pourquoi cette restriction ? Sans elle, les opérateurs seraient absorbés dans les listes d'arguments. Par exemple, b:get move != 0 pourrait être analysé comme board_get(&b, move != 0) au lieu de (board_get(&b, move)) != 0. Voir Notes de conception pour le raisonnement complet.

Référence des tokens lexicaux​

TokenMotifDescription
BSbs keywordType bitstream dynamique
IDLettre/souligné + lettres/chiffres/soulignésIdentifiant (Unicode supporté)
INTEGERDécimal, 0x hex, ou 0b binaireLittéral numérique
STRINGSimple, double ou triple guillemetsLittéral chaîne
ASSIGN=Opérateur d'affectation / littéral vrai
ADDR#Marqueur d'adresse/déréférencement
ADDR_ASSIGN#=Affectation d'adresse
ADDR_EQ=#=Égalité d'adresses
DBL_COLON::Groupement double-colon
DOTDOT..Séparateur de plage
ARROW->Préfixe d'appel de méthode
AT@Opérateur address-of
COLON:Séparateur
SEMI;Fin d'instruction
PIPE|Expression pipe
NL\n, \r, \r\nSaut de ligne

Analyseur lexical personnalisé : Gestion de l'indentation​

RamlCustomLexer.py étend l'analyseur lexical ANTLR standard pour émettre des tokens INDENT/DEDENT :

  1. Tokenization : L'analyseur lexical généré par ANTLR produit un flux de tokens standard.
  2. Suivi d'indentation : Avant chaque token, l'analyseur lexical personnalisé vérifie le niveau d'indentation de la ligne courante.
  3. INDENT/DEDENT : Si l'indentation augmente, un INDENT est injecté. Si elle diminue, un ou plusieurs DEDENT sont injectés (un par niveau).
  4. Injection SEMI : Un token SEMI (;) est optionnellement injecté à la fin des lignes d'instruction pour le support des points-virgules optionnels.
  5. Filtrage des sauts de ligne : Les lignes vides consécutives sont fusionnées.

Prédicats dans la grammaire​

La grammaire utilise des prédicats sémantiques ANTLR pour résoudre les ambiguïtés :

// Empêcher l'accès dynamique aux champs de consommer ':' comme syntaxe de type
| ID COLON simpleExprItem COLON
{ self._input.LA(1) != self.ID && self._input.LA(1) != self.COLON }?

// Empêcher les appels de méthodes d'être analysés comme des affectations
methodCallStmt
: ARROW receiver ':' ID
{ self._input.LA(1) != self.ASSIGN && self._input.LA(1) != self.COLON }?
exprList

Ces prédicats sont évalués au moment de l'analyse et désambiguïsent entre des alternatives de grammaire concurrentes sans nécessiter de restructuration.

Gestion des commentaires​

Trois styles de commentaires, tous ignorés par l'analyseur lexical :

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

Le commentaire ellipse (… texte) est unique à Raml — toute ligne commençant par … suivi d'un espace est traitée comme un commentaire. Utile pour désactiver rapidement des lignes pendant le débogage.

Organisation du fichier de grammaire​

Le fichier de grammaire (source/Raml.g4) est organisé en :

  1. Tokens de l'analyseur lexical (lignes 1-80) : Définitions de mots-clés, tokens d'opérateurs, motifs de littéraux
  2. Règles de l'analyseur (lignes 82-fin) : Structure du programme, déclarations, flux de contrôle, expressions
  3. Règnes fragment : Règles auxiliaires pour l'analyseur lexical (ex. TRIPLE_DQUOTE)

Sorties ANTLR générées :

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

Voir Référence de la grammaire pour le fichier de grammaire ANTLR complet.