LLg is een recursieve generator van de afdalingssyntactische parser.

SYNOPSIS

gebruik LLg;
@tokens = (
ADDOP => [- +],
LEFTP => [(],
RIGHTP => [)],
GEHEEL => 0|[1-9] [0-9] *,
);
$reader = Lex->new (@tokens);
$ADDOP->debug;

$expr = And->new (($factor, Any->new ($ADDOP, $factor)),
sub {
verschuiving (@_);
mijn $result = verschuiving (@_);
mijn ($op, $integer);
terwijl ($#_ >= 0) {
($op, $integer) = (verschuiving (@_), verschuiving (@_));
als ($op eq +) {
$result += $integer;
} anders {
$result - = $integer;
}
}
$result;
});
$factor = Or->new ($INTEGER, $parexp);
$parexp = And->new ($LEFTP, $expr, $RIGHTP,
sub {$_ [2]});

druk STDERR „Type uw rekenkundige uitdrukking: “;
druk „Resultaat: “, $expr->next, „n“;

Creëren van syntactische parsers door hand is vervelend zelfs voor eenvoudige talen. Deze activiteit kan door parser-generators worden geautomatiseerd - yacc is een bekend voorbeeld. Maar gebruiken van dergelijke hulpmiddelen is vrij eisend en vereist een redelijke kennis van de principes van syntactische analyse.

LLg is een reeks pakketten Perl5 die de generatie van recursieve afdalingssyntactische parsers voor grammatica's zonder context toestaan.

LLg wordt voorzien van de pakketten Lex en Teken die op voorwerp-gebaseerd zijn. Het gebruik van deze pakketten veronderstelt dat u het weet hoe te om een grammatica te schrijven BNF en dat u (enkel een weinig) van programmering in Perl op de hoogte bent.

Het specificeren van de syntactische parser vereist geen uitbreiding aan syntaxis Perl. De specificatie wordt uitgevoerd volledig in standaardPerl, zij het definitie van tekenen, syntactische regels of bijbehorende semantische acties. LLg staat de gemakkelijke specificatie van vertaalregelingen toe, die syntactische parsers is waarvoor de semantische actie door acties direct verbonden aan elke productie wordt gegeven.

Het pakkettenTeken en LLg staan respectievelijk de definitie van voorwerpen toe die aan terminals (tekenen) beantwoorden en niet-terminals van de grammatica. Lex behandelt de lezing en „het eten“ van tekenen in de inputstroom.

Alvorens deze pakketten te gebruiken moet u een grammatica BNF zonder linkerterugkeer (een (1) bepalen grammatica LL). Gezien dit, die de syntactische parser maakt bestaat uit:

1. leidt tot een lexicale analisator door de terminals te specificeren,
2. leiden tot een syntactische parser (syntactische analisator) door een voorwerp LLg (of, meer bepaald, één van de pakketten wat van LLg) erft voor non-terminal elk te creëren.
3. bepalen de semantiek door een anonieme functie met elk voorwerp te associëren LLg.

Neem als voorbeeld rekenkundige uitdrukkingen die slechts + en - als exploitanten hebben. In het boek van de Kameel vinden wij de volgende grammatica:

expr:: = factor {factor ADDOP}
ADDOP:: = + | -
factor:: = AANTAL | (expr)

Het creëren van de syntactische parser voor deze taal impliceert het bepalen van een lexicale analisator en een syntactische analisator.

De lexicale analisator wordt bepaald thusly:

@tokens = (
ADDOP => [- +],
LEFTP => [(],
RIGHTP => [)],
GEHEEL => [1-9] [0-9] *,
);
$reader = Lex->new (@tokens);

Het argument van de nieuwe methode () is een lijst van paren: de identiteit van de terminal en de overeenkomstige regelmatige uitdrukking. Elk dergelijk paar leidt tot de verwezenlijking van een terminal van typeTeken.

Het pakket LLg is het basispakket van een reeks: En, om het even welk, haken, opteren, vast of. Deze pakketten staan de verwezenlijking van de verschillende die soorten regels toe normaal in grammatica's zonder context worden gevonden. Wij gebruiken een prefixaantekening met de volgende gelijkwaardigheid.

A | B Or->new ($A, $B) symbool A of symbool B


Symbool A een van B And->new ($A, $B) door symbool B wordt gevolgd die


{A} ($A) willekeurig aantal Any->new van A


[A het voorkomen] van Opt->new ($A) nul of één van A

De regels in ons voorbeeld worden gegeven door de volgende voorwerpen te creëren:

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

De argumenten van de nieuwe methode () zijn verwijzingen naar LLg of Symbolische voorwerpen. (De geschreven orde van de regel heeft geen betekenis, aangezien scalars verwijzingen kan zijn alvorens zij een waarde worden toegewezen. Deze verwijzingen worden opgelost wanneer elk voorwerp wordt gebruikt. Zoals het voorbeeld toont dat, kunnen de verwijzingen worden verkregen naar de voorwerpen door een regel zijn teruggekeerd.)

De semantiek wordt bepaald door een anonieme functie aan het eind van de lijst van objecten verwijzingen te zetten. De anonieme functie gebruikt informatie verbonden aan de voorwerpen. Deze informatie wordt doorgegeven door positionele parameters (de serie @_). Het nth argument wijst het resultaat van de nth parameter van de nieuwe methode aan (). De informatie door de functie is teruggekeerd wordt geassoci downloaden