view release on metacpan or  search on metacpan

lib/MarpaX/Java/ClassFile/Role/Parser.pm  view on Meta::CPAN

use strict;
use warnings FATAL => 'all';

package MarpaX::Java::ClassFile::Role::Parser;

# ABSTRACT: Parsing engine role for .class file parsing

our $VERSION = '0.009'; # VERSION

our $AUTHORITY = 'cpan:JDDPAUSE'; # AUTHORITY

use Moo::Role;
#
# Note: This package is part of the core of the engine. Therefore it
# optimized except the logging (when you trace this package, I assume
# you are not interested in micro-optimizations)
#
use Carp qw/croak/;
use MarpaX::Java::ClassFile::Util::MarpaTrace qw//;
use MarpaX::Java::ClassFile::Util::ProductionMode qw/prod_isa/;
use Data::Section -setup;
use Scalar::Util qw/blessed/;
use Types::Common::Numeric qw/PositiveOrZeroInt/;
use Types::Standard qw/Any ScalarRef Bool ArrayRef Str Undef ConsumerOf InstanceOf/;
use Types::Encodings qw/Bytes/;


#
# Required parameters
#
has inputRef            => ( is => 'ro',  prod_isa(ScalarRef[Bytes]),                                                  required => 1);
#
# Parameters with a default
#
has marpaRecceHook      => ( is => 'ro',  prod_isa(Bool),                                                      default => sub { 1 });
has constant_pool_count => ( is => 'ro',  prod_isa(PositiveOrZeroInt),                                         default => sub { 0 } );
has constant_pool       => ( is => 'ro',  prod_isa(ArrayRef),                                                  default => sub { [] });
has pos                 => ( is => 'rwp', prod_isa(PositiveOrZeroInt),                                         default => sub { 0 });
has exhaustion          => ( is => 'ro',  prod_isa(Str),                                                       default => sub { 'event' });
has parent              => ( is => 'ro',  prod_isa(Undef|ConsumerOf['MarpaX::Java::ClassFile::Role::Parser']), default => sub { return });
#
# Lazy parameters
#
has max                 => ( is => 'rwp', prod_isa(PositiveOrZeroInt),                                         lazy => 1, builder => 1);
has whoami              => ( is => 'ro',  prod_isa(Str),                                                       lazy => 1, builder => 1);
has ast                 => ( is => 'ro',  prod_isa(Any),                                                       lazy => 1, builder => 1);

my $MARPA_TRACE_FILE_HANDLE;
my $MARPA_TRACE_BUFFER;
my %_registrations = ();
my %_DOES_INNERGRAMMAR = ();

sub BEGIN {
    #
    ## We do not want Marpa to pollute STDERR
    #
    ## Autovivify a new file handle
    #
    open($MARPA_TRACE_FILE_HANDLE, '>', \$MARPA_TRACE_BUFFER);
    if (! defined($MARPA_TRACE_FILE_HANDLE)) {
      croak "Cannot create temporary file handle to tie Marpa logging, $!\n";
    } else {
      if (! tie ${$MARPA_TRACE_FILE_HANDLE}, 'MarpaX::Java::ClassFile::Util::MarpaTrace') {
        croak "Cannot tie $MARPA_TRACE_FILE_HANDLE, $!\n";
        if (! close($MARPA_TRACE_FILE_HANDLE)) {
          croak "Cannot close temporary file handle, $!\n";
        }
        $MARPA_TRACE_FILE_HANDLE = undef;
      }
    }
}

sub _build_max {
  # my ($self) = @_;
  length(${$_[0]->inputRef})
}

sub _build_whoami {
  # my ($self, $class) = @_;
  my $whoami = (split(/::/, $_[1] // blessed($_[0])))[-1];

  return join('->', $_[0]->parent->whoami, $whoami) if (defined($_[0]->parent));
  $whoami
}

# -----------------------
# General events dispatch
# -----------------------
sub manageEvents {
  # my ($self) = @_;

  my @eventNames = map { $_->[0] } (@{$_[0]->_events});
  # $_[0]->tracef('Events: %s', \@eventNames);
  foreach (@eventNames) {
    $_[0]->tracef('--------- %s', $_);
    my $callback = $_[0]->callbacks->{$_};
    $_[0]->_croak("Unmanaged event $_") unless defined($callback);