X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=lib%2FPerl%2FTidy%2FIndentationItem.pm;h=9244a03c8f78da779f8fe58192fb7f3fdd73a279;hb=880633cc084e9d787eb9f760d3851c5d660db17c;hp=7a6c10062f27cb654bba7114faf6f7993266e354;hpb=7f27e55dce5925b2bbe8fcfca64f385e917a52be;p=perltidy.git

diff --git a/lib/Perl/Tidy/IndentationItem.pm b/lib/Perl/Tidy/IndentationItem.pm
index 7a6c100..9244a03 100644
--- a/lib/Perl/Tidy/IndentationItem.pm
+++ b/lib/Perl/Tidy/IndentationItem.pm
@@ -8,25 +8,62 @@
 package Perl::Tidy::IndentationItem;
 use strict;
 use warnings;
-our $VERSION = '20200110';
+our $VERSION = '20220217';
+
+BEGIN {
+
+    # Array index names
+    # Do not combine with other BEGIN blocks (c101).
+    my $i = 0;
+    use constant {
+        _spaces_             => $i++,
+        _level_              => $i++,
+        _ci_level_           => $i++,
+        _available_spaces_   => $i++,
+        _closed_             => $i++,
+        _comma_count_        => $i++,
+        _lp_item_index_      => $i++,
+        _have_child_         => $i++,
+        _recoverable_spaces_ => $i++,
+        _align_seqno_        => $i++,
+        _marked_             => $i++,
+        _stack_depth_        => $i++,
+        _K_begin_line_       => $i++,
+        _arrow_count_        => $i++,
+    };
+}
+
+sub AUTOLOAD {
+
+    # Catch any undefined sub calls so that we are sure to get
+    # some diagnostic information.  This sub should never be called
+    # except for a programming error.
+    our $AUTOLOAD;
+    return if ( $AUTOLOAD =~ /\bDESTROY$/ );
+    my ( $pkg, $fname, $lno ) = caller();
+    my $my_package = __PACKAGE__;
+    print STDERR <<EOM;
+======================================================================
+Error detected in package '$my_package', version $VERSION
+Received unexpected AUTOLOAD call for sub '$AUTOLOAD'
+Called from package: '$pkg'  
+Called from File '$fname'  at line '$lno'
+This error is probably due to a recent programming change
+======================================================================
+EOM
+    exit 1;
+}
+
+sub DESTROY {
+
+    # required to avoid call to AUTOLOAD in some versions of perl
+}
 
 sub new {
 
     # Create an 'indentation_item' which describes one level of leading
     # whitespace when the '-lp' indentation is used.
-    my (
-        $class,               $spaces,           $level,
-        $ci_level,            $available_spaces, $index,
-        $gnu_sequence_number, $align_paren,      $stack_depth,
-        $starting_index,
-    ) = @_;
-
-    my $closed            = -1;
-    my $arrow_count       = 0;
-    my $comma_count       = 0;
-    my $have_child        = 0;
-    my $want_right_spaces = 0;
-    my $marked            = 0;
+    my ( $class, %input_hash ) = @_;
 
     # DEFINITIONS:
     # spaces             =>  # total leading white spaces
@@ -36,36 +73,36 @@ sub new {
     #                        # for this level
     # closed             =>  # index where we saw closing '}'
     # comma_count        =>  # how many commas at this level?
-    # sequence_number    =>  # output batch number
-    # index              =>  # index in output batch list
+    # lp_item_index     =>  # index in output batch list
     # have_child         =>  # any dependents?
     # recoverable_spaces =>  # how many spaces to the right
     #                        # we would like to move to get
     #                        # alignment (negative if left)
-    # align_paren        =>  # do we want to try to align
-    #                        # with an opening structure?
+    # align_seqno        =>  # if we are aligning with an opening structure,
+    #                        # this is its seqno
     # marked             =>  # if visited by corrector logic
     # stack_depth        =>  # indentation nesting depth
-    # starting_index     =>  # first token index of this level
+    # K_begin_line   =>  # first token index K of this level
     # arrow_count        =>  # how many =>'s
 
-    return bless {
-        _spaces             => $spaces,
-        _level              => $level,
-        _ci_level           => $ci_level,
-        _available_spaces   => $available_spaces,
-        _closed             => $closed,
-        _comma_count        => $comma_count,
-        _sequence_number    => $gnu_sequence_number,
-        _index              => $index,
-        _have_child         => $have_child,
-        _recoverable_spaces => $want_right_spaces,
-        _align_paren        => $align_paren,
-        _marked             => $marked,
-        _stack_depth        => $stack_depth,
-        _starting_index     => $starting_index,
-        _arrow_count        => $arrow_count,
-    }, $class;
+    my $self = [];
+    $self->[_spaces_]             = $input_hash{spaces};
+    $self->[_level_]              = $input_hash{level};
+    $self->[_ci_level_]           = $input_hash{ci_level};
+    $self->[_available_spaces_]   = $input_hash{available_spaces};
+    $self->[_closed_]             = -1;
+    $self->[_comma_count_]        = 0;
+    $self->[_lp_item_index_]      = $input_hash{lp_item_index};
+    $self->[_have_child_]         = 0;
+    $self->[_recoverable_spaces_] = 0;
+    $self->[_align_seqno_]        = $input_hash{align_seqno};
+    $self->[_marked_]             = 0;
+    $self->[_stack_depth_]        = $input_hash{stack_depth};
+    $self->[_K_begin_line_]       = $input_hash{K_begin_line};
+    $self->[_arrow_count_]        = 0;
+
+    bless $self, $class;
+    return $self;
 }
 
 sub permanently_decrease_available_spaces {
@@ -80,7 +117,12 @@ sub permanently_decrease_available_spaces {
       ( $available_spaces > $spaces_needed )
       ? $spaces_needed
       : $available_spaces;
-    $item->decrease_available_spaces($deleted_spaces);
+
+    # Fixed for c085; a zero value must remain unchanged unless the closed
+    # flag has been set.
+    my $closed = $item->get_closed();
+    $item->decrease_available_spaces($deleted_spaces)
+      unless ( $available_spaces == 0 && $closed < 0 );
     $item->decrease_SPACES($deleted_spaces);
     $item->set_recoverable_spaces(0);
 
@@ -106,149 +148,135 @@ sub tentatively_decrease_available_spaces {
 }
 
 sub get_stack_depth {
-    my $self = shift;
-    return $self->{_stack_depth};
+    return $_[0]->[_stack_depth_];
 }
 
 sub get_spaces {
-    my $self = shift;
-    return $self->{_spaces};
+    return $_[0]->[_spaces_];
 }
 
 sub get_marked {
-    my $self = shift;
-    return $self->{_marked};
+    return $_[0]->[_marked_];
 }
 
 sub set_marked {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_marked} = $value;
+        $self->[_marked_] = $value;
     }
-    return $self->{_marked};
+    return $self->[_marked_];
 }
 
 sub get_available_spaces {
-    my $self = shift;
-    return $self->{_available_spaces};
+    return $_[0]->[_available_spaces_];
 }
 
 sub decrease_SPACES {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_spaces} -= $value;
+        $self->[_spaces_] -= $value;
     }
-    return $self->{_spaces};
+    return $self->[_spaces_];
 }
 
 sub decrease_available_spaces {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_available_spaces} -= $value;
+        $self->[_available_spaces_] -= $value;
     }
-    return $self->{_available_spaces};
+    return $self->[_available_spaces_];
 }
 
-sub get_align_paren {
-    my $self = shift;
-    return $self->{_align_paren};
+sub get_align_seqno {
+    return $_[0]->[_align_seqno_];
 }
 
 sub get_recoverable_spaces {
-    my $self = shift;
-    return $self->{_recoverable_spaces};
+    return $_[0]->[_recoverable_spaces_];
 }
 
 sub set_recoverable_spaces {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_recoverable_spaces} = $value;
+        $self->[_recoverable_spaces_] = $value;
     }
-    return $self->{_recoverable_spaces};
+    return $self->[_recoverable_spaces_];
 }
 
 sub increase_recoverable_spaces {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_recoverable_spaces} += $value;
+        $self->[_recoverable_spaces_] += $value;
     }
-    return $self->{_recoverable_spaces};
+    return $self->[_recoverable_spaces_];
 }
 
 sub get_ci_level {
-    my $self = shift;
-    return $self->{_ci_level};
+    return $_[0]->[_ci_level_];
 }
 
 sub get_level {
-    my $self = shift;
-    return $self->{_level};
+    return $_[0]->[_level_];
 }
 
-sub get_sequence_number {
+sub get_spaces_level_ci {
     my $self = shift;
-    return $self->{_sequence_number};
+    return [ $self->[_spaces_], $self->[_level_], $self->[_ci_level_] ];
 }
 
-sub get_index {
-    my $self = shift;
-    return $self->{_index};
+sub get_lp_item_index {
+    return $_[0]->[_lp_item_index_];
 }
 
-sub get_starting_index {
-    my $self = shift;
-    return $self->{_starting_index};
+sub get_K_begin_line {
+    return $_[0]->[_K_begin_line_];
 }
 
 sub set_have_child {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_have_child} = $value;
+        $self->[_have_child_] = $value;
     }
-    return $self->{_have_child};
+    return $self->[_have_child_];
 }
 
 sub get_have_child {
-    my $self = shift;
-    return $self->{_have_child};
+    return $_[0]->[_have_child_];
 }
 
 sub set_arrow_count {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_arrow_count} = $value;
+        $self->[_arrow_count_] = $value;
     }
-    return $self->{_arrow_count};
+    return $self->[_arrow_count_];
 }
 
 sub get_arrow_count {
-    my $self = shift;
-    return $self->{_arrow_count};
+    return $_[0]->[_arrow_count_];
 }
 
 sub set_comma_count {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_comma_count} = $value;
+        $self->[_comma_count_] = $value;
     }
-    return $self->{_comma_count};
+    return $self->[_comma_count_];
 }
 
 sub get_comma_count {
-    my $self = shift;
-    return $self->{_comma_count};
+    return $_[0]->[_comma_count_];
 }
 
 sub set_closed {
     my ( $self, $value ) = @_;
     if ( defined($value) ) {
-        $self->{_closed} = $value;
+        $self->[_closed_] = $value;
     }
-    return $self->{_closed};
+    return $self->[_closed_];
 }
 
 sub get_closed {
-    my $self = shift;
-    return $self->{_closed};
+    return $_[0]->[_closed_];
 }
 1;