The Perl Toolchain Summit needs more sponsors. If your company depends on Perl, please support this very important event.
# Marpa::R3 is Copyright (C) 2016, 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 it is provided “as is” and without any express
# or implied warranties. For details, see the full text of
# of the licenses in the directory LICENSES.

=head1 NAME

Marpa::R3::Semantics::Phases - SLIF recognizer phases

=head1 About this document

This document describes in detail the sequence of events
in the SLIF recognizer.
It serves two purposes.

=over 4

=item *

It describes the sequence of events
in the SLIF recognizer
in fuller detail
than the other documents do.

=item *

It describes the use of more than one parse series.

=back

Full detail of the sequence of events
inside the SLIF recognizer
is not usually necessary.
Applications usually
find that things "just work".
But some application B<do> depend on the details.
These include

=over 4

=item *

applications which make unusual use of side effects in the semantics; and

=item *

applications which alter their symbol tables at runtime.

=back

=head1 Parse trees and parse series

Because Marpa allows ambiguous parsing,
each parse can produce a
a series of zero or more parse trees,
-- a B<parse series>.
Each parse tree has its own parse result.
Because the parse may fail,
there may be zero parse
trees in a parse series.
Because a parse may be ambiguous,
there may be more than one parse tree
in a parse series.

The SLIF allows the recognizer to
be run several times on the same
virtual input stream.
Each of these runs is a separate B<parse series>.
Most applications use only
one parse series.

The call to the
L<SLIF recognizer's C<read()>
method|Marpa::R3::Scanless::R/"read()">
is the
start of the first parse series.
The first parse series continues until there is
a call to the
L<C<series_restart()>
method|Marpa::R3::Scanless::R/"series_restart()">
or until the recognizer is destroyed.
Each call of the C<series_restart()> method
starts a new parse series.

Few applications need to use more than
a single parse series.
But they are useful in some specialized
applications.
Starting a new parse series allows the applications
to change some settings
and to extend the input.
Specifically,

=over 4

=item *

Once input is read into a SLIF recognizer's
virtual input stream, it is there for the life of the recognizer.
It cannot be "unread".
But during the Reading Phase of a new parse series,
a recognizer can extend the virtual input stream,
using the recognizer's
L<C<resume()> method|Marpa::R3::Scanless::R/"resume()">.

=item *

Within a parse series,
the semantics package cannot change.
But you can specify a new semantics package
after starting a new parse series.

=item *

Certain other SLIF recognizer settings can be
changed
after starting a new parse series.
These include the SLIF recognizer's
L<C<end> setting|Marpa::R3::Scanless::R/"end">.
For details, see
L<Marpa::R3::Scanless::R/"Recognizer settings">.

=back

=head1 SLIF recognizer phases

A SLIF recognizer is always in one of three phases:

=over 4

=item * The Initial Phase;

=item * a Reading Phase; or

=item * an Evaluation Phase.

=back

In these documents,
phase and subphase names are capitalized
for clarity.

Reading and Evaluation Phases
are always part of a parse series.
The Initial Phase is never part of any parse series.

=head1 The Initial Phase

The B<Initial Phase> of a SLIF recognizer
begins when the recognizer is created with the
a call of the L<C<new()>|Marpa::R3::Scanless::R/"Constructor"> method.
It ends when
the L<C<read()>|Marpa::R3::Scanless::R/"read()"> method
is called.
It will also end, of course, if
the recognizer is destroyed,
but most applications will want to
continue into the next phases.

There is always exactly one Initial Phase for
every recognizer.
The Initial Phase is not part of any parse series.
Very little can happen in the Initial Phase,
but it is possible to change some recognizer settings
using the L<C<set()>|Marpa::R3::Scanless::R/"set()"> method.

=head1 The Reading Phase

The Reading Phase starts
when a parse series starts,
that is,
with either a call to the
L<C<read()>
method|Marpa::R3::Scanless::R/"read()">
or a call to the
L<C<series_restart()>
method|Marpa::R3::Scanless::R/"series_restart()">.
The Reading Phase ends when the first of the following occurs:

=over 4

=item *

The C<value()> method is called for this SLIF recognizer.
This is the most common case.

=item *

A new parse series is begun
by calling the C<series_restart()> method.

=item *

The recognizer is destroyed.

=back

The last two cases are unusual.
Applications almost always
want to continue the parse series into the Evaluation Phase
by calling the C<value()> method.

The C<read()> method can be called only once for a SLIF recognizer.
But, while a Reading Phase continues,
the C<resume()> method may be called multiple times to continue reading
input.
The C<resume()> method should only be called except during the
Reading Phase of a parse series.

A Reading Phase is always part of a parse series.
There is always exactly one Reading Phase for every parse series.

=head1 The Evaluation Phase

The Evaluation Phase begins with a recognizer's first call
to the SLIF's C<value()> method.
It ends when the recognizer is destroyed,
or when
the SLIF's C<series_restart()> method
is called for that recognizer.
If a parse series ends before the C<value()> method is
called, there is no Evaluation Phase.

The L<C<value()>|Marpa::R3::Scanless::R/"value()"> method
may be called more than once during the Evaluation Phase.
The second and later calls of
the L<C<value()>|Marpa::R3::Scanless::R/"value()"> method will return
the result of the next parse tree, if there is one.
When there are no more parse trees,
the L<C<value()>|Marpa::R3::Scanless::R/"value()"> method will return
a Perl C<undef>.

If you call
the L<C<resume()>|Marpa::R3::Scanless::R/"resume()"> method
during an Evaluation Phase,
the behavior of
Marpa::R3
is not defined.
You should not do this.

When it occurs, an Evaluation Phase is always part of a parse series.
But the Evaluation Phase is optional --
a parse series may end without entering into an Evalution Phase.

The Evaluation Phase has two subphases:

=over 4

=item *

The Parse Tree Setup Subphase.

=item *

The Parse Tree Traveral Subphase.

=back

B<Node Evaluation Time>
is the Tree Traversal Subphase, as seen from the point of view of
each rule node.  It is not a separate phase.

=head1 Parse Tree Setup Subphase

The Parse Tree Setup Subphase
occurs during during the first call
to the C<value()> method of every series.
In the Parse Tree Setup Subphase, the following happens:

=over 4

=item *

If a per-parse argument was not supplied in the
C<value()> method, the
default per-parse argument is created.

=item *

All action names are resolved to
actions --
Perl scalars
or rule evaluation closures.
The rule evaluation closures are not called in the Parse Tree Setup Subphase.
They will be called later,
in the Parse Tree Traversal Subphase.

=back

Exactly one Parse Tree Setup Subphase occurs
for each parse tree.

=head1 Parse Tree Traversal Subphase

During the Parse Tree Traversal Subphase,
the rule evaluation closures are called.

=head1 COPYRIGHT AND LICENSE

=for Marpa::R3::Display
ignore: 1

  Marpa::R3 is Copyright (C) 2016, 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.

=for Marpa::R3::Display::End

=cut

# vim: expandtab shiftwidth=4: