File Coverage

blib/lib/MarpaX/Languages/ECMAScript/AST/Impl.pm

Criterion	Covered	Total	%
statement	7	9	77.7
branch			n/a
condition			n/a
subroutine	3	3	100.0
pod			n/a
total	10	12	83.3

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

package MarpaX::Languages::ECMAScript::AST::Impl;

# ABSTRACT: Implementation of Marpa's interface

use Marpa::R2 2.080000;
use MarpaX::Languages::ECMAScript::AST::Exceptions qw/:all/;
use MarpaX::Languages::ECMAScript::AST::Impl::Logger;
use MarpaX::Languages::ECMAScript::AST::Impl::Singleton;

our $VERSION = '0.020'; # VERSION

our $MARPA_TRACE_FILE_HANDLE;
our $MARPA_TRACE_BUFFER;

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)) {
      InternalError(error => "Cannot create temporary file handle to tie Marpa logging, $!\n");
    } else {
      if (! tie ${$MARPA_TRACE_FILE_HANDLE}, 'MarpaX::Languages::ECMAScript::AST::Impl::Logger') {
        InternalError(error => "Cannot tie $MARPA_TRACE_FILE_HANDLE, $!\n");
        if (! close($MARPA_TRACE_FILE_HANDLE)) {
          InternalError(error => "Cannot close temporary file handle, $!\n");
        }
        $MARPA_TRACE_FILE_HANDLE = undef;
      }
    }
}

our $singleton = MarpaX::Languages::ECMAScript::AST::Impl::Singleton->instance();


sub new {
  my ($class, $grammarOptionsHashp, $recceOptionsHashp) = @_;

  my $self->{grammar} = $singleton->G($grammarOptionsHashp);

  if (defined($recceOptionsHashp)) {
      $recceOptionsHashp->{grammar} = $self->{grammar};
  } else {
      $recceOptionsHashp = {grammar => $self->{grammar}};
  }
  $recceOptionsHashp->{trace_terminals} = $ENV{MARPA_TRACE_TERMINALS} || $ENV{MARPA_TRACE} || 0;
  $recceOptionsHashp->{trace_values} = $ENV{MARPA_TRACE_VALUES} || $ENV{MARPA_TRACE} || 0;
  $recceOptionsHashp->{trace_file_handle} = $MARPA_TRACE_FILE_HANDLE;
  #
  # Save recceOptionsHashp for further use
  #
  $self->{_recceOptionsHashp} = $recceOptionsHashp;

  bless($self, $class);

  return $self;
}


sub make_R {
    $_[0]->{recce} = Marpa::R2::Scanless::R->new($_[0]->{_recceOptionsHashp});
}


sub destroy_R {
    $_[0]->{recce} = undef;
}


sub value {
  return $_[0]->{recce}->value(@_[1..$#_]);
}


sub read {
  return $_[0]->{recce}->read(@_[1..$#_]);
}


sub resume {
  return $_[0]->{recce}->resume(@_[1..$#_]);
}


sub last_completed {
  return $_[0]->{recce}->last_completed(@_[1..$#_]);
}


sub last_completed_range {
  return $_[0]->{recce}->last_completed_range(@_[1..$#_]);
}


sub range_to_string {
  return $_[0]->{recce}->range_to_string(@_[1..$#_]);
}


sub event {
  return $_[0]->{recce}->event(@_[1..$#_]);
}


sub events {
  return $_[0]->{recce}->events();
}


sub pause_lexeme {
  return $_[0]->{recce}->pause_lexeme(@_[1..$#_]);
}


sub pause_span {
  return $_[0]->{recce}->pause_span(@_[1..$#_]);
}


sub literal {
  return $_[0]->{recce}->literal(@_[1..$#_]);
}


sub line_column {
  return $_[0]->{recce}->line_column(@_[1..$#_]);
}


sub substring {
  return $_[0]->{recce}->substring(@_[1..$#_]);
}


sub lexeme_read {
  return $_[0]->{recce}->lexeme_read(@_[1..$#_]);
}


sub current_g1_location {
  return $_[0]->{recce}->current_g1_location(@_[1..$#_]);
}


sub g1_location_to_span {
  return $_[0]->{recce}->g1_location_to_span(@_[1..$#_]);
}


sub terminals_expected {
  return $_[0]->{recce}->terminals_expected(@_[1..$#_]);
}


sub show_progress {
  return $_[0]->{recce}->show_progress(@_[1..$#_]);
}


sub progress {
  return $_[0]->{recce}->progress(@_[1..$#_]);
}


sub grammar {
  return $_[0]->{grammar};
}


sub G {
  return $_[0]->grammar;
}


sub recce {
  return $_[0]->{recce};
}


sub R {
  return $_[0]->recce;
}


sub rule_ids {
  return $_[0]->{grammar}->rule_ids(@_[1..$#_]);
}


sub rule_expand {
  return $_[0]->{grammar}->rule_expand(@_[1..$#_]);
}


sub symbol_name {
  return $_[0]->{grammar}->symbol_name(@_[1..$#_]);
}


1;

__END__