LLg est un générateur de programme d'analyse syntaxique récursif d'origine généalogique.

SYNTHÈSE

employer LLg ;
@tokens = (
=> d'ADDOP [- +],
=> de LEFTP [(],
=> de RIGHTP [)],
=> 0 de NOMBRE ENTIER|[1-9] [0-9] *,
) ;
$reader = Lex->new (@tokens) ;
$ADDOP->debug ;

$expr = And->new (($factor, Any->new ($ADDOP, $factor)),
sous-marin {
commande des vitesses (@_) ;
mon $result = commande des vitesses (@_) ;
mon ($op, $integer) ;
tandis que (>= 0 de $#_) {
($op, $integer) = (commande des vitesses (@_), commande des vitesses (@_));
si (eq de $op +) {
$result += $integer ;
} autrement {
$result - = $integer ;
}
}
$result ;
}) ;
$factor = Or->new ($INTEGER, $parexp) ;
$parexp = And->new ($LEFTP, $expr, $RIGHTP,
sous-marin {$_ [2]}) ;

type de l'impression STDERR « votre expression arithmétique :  » ;
résultat d'impression « :  », $expr->next, « n » ;

Produire des programmes d'analyse syntaxique est à la main pénible même pour des langages simples. Cette activité peut être automatisée par des programme d'analyse syntaxique-générateurs - le yacc est un exemple bien connu. Mais à l'aide de tels outils est tout à fait exigeant et exige une connaissance raisonnable des principes de l'analyse syntactique.

LLg est un ensemble d'ensembles de mesures Perl5 qui permettent le rétablissement des programmes d'analyse syntaxique récursifs d'origine généalogique pour des grammaires indépendantes du contexte.

LLg est équipé d'ensembles de mesures Lex et de jeton qui objectif-sont basés. L'utilisation de ces ensembles de mesures présuppose que vous savez sauver une grammaire de BNF et que vous savez (juste) la programmation dans le Perl.

La spécification du programme d'analyse syntaxique n'exige aucune prolonge à la syntaxe de Perl. Le cahier des charges est effectué entièrement dans le Perl normal, que ce soit la définition des jetons, des règles syntactiques ou des actions sémantiques associées. LLg permet le cahier des charges facile des arrangements de traduction, celui est des programmes d'analyse syntaxique pour lesquels l'action sémantique est donnée par des actions directement liées à chaque production.

Le jeton et le LLg d'ensembles de mesures permettent respectivement la définition des objectifs correspondant aux bornes (jetons) et aux non-bornes de la grammaire. Lex traite le relevé et la « consommation » des jetons dans le train d'entrées.

Avant d'employer ces ensembles de mesures vous devez définir une grammaire de BNF sans récursion gauche (un LL (1) grammaire). Donné ceci, effectuer le programme d'analyse syntaxique consiste en :

1. produire un analyseur lexicologique en spécifiant les bornes,
2. produire un programme d'analyse syntaxique (analyseur syntactique) en produisant un objectif de LLg (ou, plus avec précision, un des ensembles de mesures qui héritent de LLg) pour chacun non terminal.
3. définir la sémantique en associant un fonctionnement anonyme à chaque objectif de LLg.

Prendre comme exemple les expressions arithmétiques ayant seulement + et - comme conducteurs. Dans le livre de chameau nous trouvons la grammaire suivante :

expr : : = facteur {facteur d'ADDOP}
ADDOP : : = + | -
facteur : : = NUMÉRO | (expr)

Produire le programme d'analyse syntaxique pour ce langage concerne définir un analyseur lexicologique et un analyseur syntactique.

L'analyseur lexicologique est défini thusly :

@tokens = (
=> d'ADDOP [- +],
=> de LEFTP [(],
=> de RIGHTP [)],
=> de NOMBRE ENTIER [1-9] [0-9] *,
) ;
$reader = Lex->new (@tokens) ;

L'argument de la méthode neuve () est une liste de paires : l'identité de la borne et de l'expression régulière correspondante. Chaque une telle paire mène à la création d'une borne de type jeton.

L'ensemble de mesures LLg est l'ensemble de mesures de base d'un jeu : Et, en font, le crochet, choisir, ou. Ces ensembles de mesures permettent la création des différents types de règles normalement trouvées dans des grammaires indépendantes du contexte. Nous employons une notation de préfixe avec les équivalences suivantes.

A | B Or->new ($A, $B) symbole A ou symbole B


Un B And->new ($A, $B) symbole A suivi de symbole B


{A} Any->new ($A) nombre arbitraire d'A


[A] Opt->new ($A) zéro ou un cas d'A

Les règles dans notre exemple sont données en produisant les objectifs suivants :

$expr = And->new (($factor, Any->new ($ADDOP, $factor));
$factor = Or->new ($NUMBER, $parexp) ;
$parexp = And->new ($LEFTP, $expr, $RIGHTP) ;

Les arguments de la méthode neuve () sont des références à LLg ou à objectifs symboliques. (La commande sauvée de la règle n'a aucune signification, puisque les grandeurs scalaires peuvent être des références avant qu'elles soient affectées une valeur. Ces références sont resolved quand chaque objectif est employé. Pendant que l'exemple montre, des références peuvent être obtenues aux objectifs retournés par une règle.)

La sémantique est définie en mettant un fonctionnement anonyme à la fin de la liste de références d'objectif. Le fonctionnement anonyme emploie l'information liée aux objectifs. Cette information est transmise par des paramètres positionnels (le @_ de choix). Le nième argument montre le résultat du nième paramètre de la méthode neuve (). L'information renvoyée par le fonctionnement est associée à l'objectif et est transmise au moyen de paramètres positionnels partout où l'objectif est employé. Dans notre exemple nous aurons :

$expr = And->new (($factor, Any->new ($ADDOP, $factor)),
sous-marin {
commande des vitesses (@_) ;
mon $result = commande des vitesses (@_) ;
mon ($op, $integer) ;
tandis que (>= 0 de $#_) {
($op, $integer) = (commande des vitesses (@_), commande des vitesses (@_));
si (eq de $op +) {
$result += $integer ;
} autrement {
$result - = $integer ;
}
}
$result ;
}) ;
$factor = Or->new ($INTEGER, $parexp) ;
$parexp = And->new ($LEFTP, $expr, $RIGHTP,
sous-marin {$_ [2]}) ;

type de l'impression STDERR « votre expression arithmétique :  » ;
résultat d'impression « :  », $expr->next, « n » ;

Quand un nombre entier est identifié il est retourné par l'anonyme fonctionnent associé à l'objectif $factor. Cette information renvoyée (ou, plus avec précision, synthétisé, puisqu'elle vient de l'une borne et est transmise aux non-bornes) est également procurable dans le fonctionnement anonyme lié à l'objectif $expr. L'information renvoyée par l'objectif suivant est employée pour prévoir la valeur de l'expression arithmétique.

L'analyseur est commencé vers le haut en s'appliquant la méthode ensuite () à l'axiome de la grammaire :

$expr->next ;

Par défaut l'entrée pour l'analyse est affichée de l'entrée normale. Le programme d'analyse syntaxique d'exemple analyse et interprète différentes expressions saisies sur la borne. L'exemple calculator.pl fourni avec l'ensemble de mesures de LLg montre comment produire une boucle d'entrée permettant le relevé et l'évaluation d'arbitraire beaucoup d'expressions.
Le générateur de programme d'analyse syntaxique peut être utilisé pour d'autres buts que l'analyse d'un flot de caractère. Étant donné que les ensembles de mesures Lex, LLg et jeton, il est parfaitement possible pour définir les bornes qui sont des objectifs c.-à-d. cite d'un cours autre que le jeton. Chaque ensemble de mesures neuf définissant des bornes doit au moins avoir le mode de méthodes () et ensuite () - voient vonkoch.pl comme exemple.