/ 
Marpa-R3-4.001_054
River stage zero No dependents
/ Marpa::R3::Tutorial2

NAME

Marpa::R3::Tutorial2 - Marpa Tutorial 2

Synopsis

use Marpa::R3;

my $dsl = <<'END_OF_DSL';
Calculator ::= Expression action => ::first

Factor ::= Number action => ::first
Term ::=
    Term '*' Factor action => do_multiply
    | Factor action => ::first
Expression ::=
    Expression '+' Term action => do_add
    | Term action => ::first
Number ~ digits
digits ~ [\d]+
:discard ~ whitespace
whitespace ~ [\s]+
END_OF_DSL

my $grammar = Marpa::R3::Grammar->new(
    {
        semantics_package => 'My_Actions',
        source            => \$dsl
    }
);
my $recce       = Marpa::R3::Recognizer->new( { grammar => $grammar } );
my $input       = '42 * 1 + 7';
my $length_read = $recce->read( \$input );

die "Read ended after $length_read of ", length $input, " characters"
    if $length_read != length $input;

my $value_ref = $recce->value();
die "No parse" if not $value_ref;
my $value = ${$value_ref};

sub My_Actions::do_add {
    my ( undef, $values ) = @_;
    my ( $t1, undef, $t2 ) = @{$values};
    return $t1 + $t2;
}

sub My_Actions::do_multiply {
    my ( undef, $values ) = @_;
    my ( $t1, undef, $t2 ) = @{$values};
    return $t1 * $t2;
}

Description

Overview

This document contains a second Marpa::R3 tutorial. This tutorial demonstrates a lower level of method calls. These lower level calls allow access to more of Marpa's features. For example, users will need to use these lower level calls

  • to use parse events;

  • and to get finer control of the response to Marpa errors.

This uses the same extremely simple calculator as the tutorial in the landing page. Most of the code is exactly the same in fact, and we will skip it. Here is what is new:

Marpa::R3::Recognizer::new

my $recce = Marpa::R3::Recognizer->new( { grammar => $grammar } );

Marpa::R3::Recognizer::new creates a new recognizer. Its arguments are references to hashes of named arguments. In this example the first named argument is the required argument: "grammar". The value of the grammar named argument must be a Marpa::R3 grammar.

Marpa::R3::Recognizer::read

my $input = '42 * 1 + 7';
my $length_read = $recce->read( \$input );

To parse a string, we use the Marpa::R3::Recognizer::read() method. In its simplest form, as here, the Marpa::R3::Recognizer::read() method takes a reference to a string containing the input stream as its argument.

Checking for a premature end

die "Read ended after $length_read of ", length $input, " characters"
    if $length_read != length $input;

Most premature endings occur when a parse is exhausted. A parse is "exhausted" when there is no possible way for it to continue on to success. Premature parse exhaustion is thrown as a failure by the Marpa::R3::Recognizer::read() method, and it is not necessary to check for it explicitly.

There are other premature endings that are not necessarily failures, and which therefore are not thrown. These are Marpa::R3's parse events. Parse events are an advanced feature, and are described elsewhere. In this example, any premature ending caused by the triggering of a parse event will be caused by stray parse events -- unexpected parse events due to a mistake in writing the DSL.

Programming a stray parse event is a programming mistake that you are not likely to make, so arguably this check is not really necessary. There are no parse events, stray or otherwise, in this example. But this check is included for completeness, and as an example of a cautious programming style.

Marpa::R3::Recognizer::value

my $value_ref = $recce->value();
die "No parse" if not $value_ref;
my $value = ${$value_ref};

The Marpa::R3::Recognizer::value() method returns a reference to the parse result's value, if there was a parse result. If there was no parse result, Marpa::R3::Recognizer::value() returns undef. The value of the parse is exactly the same, and computed in exactly the same way, as in the previous tutorial.

This code implicitly checks for parse ambiguity -- parses where the input can be parsed in two or more ways. Ambiguous parses are not necessarily a problem -- some applications may not care about them. Other applications, as an advanced technique, actually exploit ambiguity, In this example, we assume that ambiguity, if it exists, is a problem.

Beginners should regard an ambiguous parse as a sign of trouble. The existence of ambiguous parses should be tolerated only if you understand the kind of ambiguity that exists in your grammar, and only if you know that ambiguities of that kind will not cause trouble.

COPYRIGHT AND LICENSE

Marpa::R3 is Copyright (C) 2018, Jeffrey Kegler.

This module is free software; you can redistribute it and/or modify it
under the same terms as Perl 5.10.1. For more details, see the full text
of the licenses in the directory LICENSES.

This program is distributed in the hope that it will be
useful, but without any warranty; without even the implied
warranty of merchantability or fitness for a particular purpose.