# programs but is useful for testing.
use constant SET_CI_OPTION_0 => 1;
- # NOTE: This is slightly different from the hash in in break_lists
- # with the same name
+ # This is slightly different from the hash in in break_lists
+ # with a similar name (removed '?' and ':' to fix t007 and others)
my %is_logical_container_for_ci;
- ## Removed ? : to fix t007 and others
- ##my @q = qw# if elsif unless while and or err not && | || ? : ! #;
my @q = qw# if elsif unless while and or err not && | || ! #;
@is_logical_container_for_ci{@q} = (1) x scalar(@q);
- # NOTE: using differnt hash than in tokenizer here, but same name:
+ # This is slightly differnt from a tokenizer hash with a similar name:
my %is_container_label_type_for_ci;
@q = qw# k && | || ? : ! #;
@is_container_label_type_for_ci{@q} = (1) x scalar(@q);
- # The following hash is set to match old ci values
+ # Undo ci of closing list paren followed by these binary operatiors:
# - initially defined for issue t027, then
# - added '=' for t015
# - added '=~' for 'locale.in'
# Set a flag which tells if sub respace_tokens has been called yet. This
# allows this sub to work either before or after respace_tokens is called.
+ # NOTE: this can eventually be removed since it will always be true
my $respace_tokens_called = defined( $rLL->[0]->[_KNEXT_SEQ_ITEM_] );
- my $token = ';';
- my $type = ';';
- my $ci_next = 0;
-
- my $last_token = $token;
- my $last_type = $type;
- my $ci_last = 0;
-
+ my $token = ';';
+ my $type = ';';
+ my $ci_next = 0;
+ my $last_token = $token;
+ my $last_type = $type;
+ my $ci_last = 0;
my $ci_next_next = 1;
+ my $rstack = ();
- my $rstack = ();
-
- # - note that ci_default = 0 only for 'List'
my $seq_root = SEQ_ROOT;
my $rparent = {
_seqno => $seq_root,
};
my $redo_preceding_comment_ci = sub {
+
+ # We need to reset the ci of the previous comment(s)
my ( $K, $ci ) = @_;
my $Km = $self->K_previous_code($K);
return if ( !defined($Km) );
return;
};
- #----------
- # Main loop
- #----------
- foreach my $KK ( 0 .. $Klimit ) {
- my $rtoken_K = $rLL->[$KK];
+ # Definitions of the sequence of ci_values being maintained:
+ # $ci_last = the ci value of the previous non-blank, non-comment token
+ # $ci_this = the ci value to be stored for this token at index $KK
+ # $ci_next = the normal ci for the next token, set by the previous tok
+ # $ci_next_next = the normal next value of $ci_next in this container
- $type = $rtoken_K->[_TYPE_];
- $token = $rtoken_K->[_TOKEN_];
+ #--------------------------
+ # Main loop over all tokens
+ #--------------------------
+ my $KK = -1;
+ foreach my $rtoken_K ( @{$rLL} ) {
- # Definitions:
- # $ci_this = the ci for this token
- # $ci_next = the ci for the next token
- # $ci_next_next = the normal next value of $ci_next in this container
+ $KK++;
+ $type = $rtoken_K->[_TYPE_];
- # Normally we use the ci value value set by previous token.
- my $ci_this = $ci_next;
+ #------------------
+ # Section 1. Blanks
+ #------------------
+ if ( $type eq 'b' ) {
- # First guess at next value uses the stored default
- # which is 0 for logical containers, 1 for other containers:
- $ci_next = $ci_next_next;
+ $rtoken_K->[_CI_LEVEL_] = $ci_next;
- # We will change these ci values necessary for special cases...
+ # 'next' to avoid saving last_ values for blanks and commas
+ next;
+ }
- #----------
- # 1. Blanks
- #----------
- if ( $type eq 'b' ) {
+ #--------------------
+ # Section 2. Comments
+ #--------------------
+ if ( $type eq '#' ) {
- $ci_next = $ci_this;
+ my $ci_this = $ci_next;
+
+ # If at '#' in ternary before a ? or :, use that level to make
+ # the comment line up with the next ? or : line. (see c202/t052)
+ # i.e. if a nested ? follows, we increase the '#' level by 1, and
+ # if a nested : follows, we decrease the '#' level by 1.
+ # This is the only place where this sub changes a _LEVEL_ value.
+ my $Kn;
+ my $parent_container_type = $rparent->{_container_type};
+ if ( $parent_container_type eq 'Ternary' ) {
+ $Kn = $self->K_next_code($KK);
+ if ($Kn) {
+ my $type_kn = $rLL->[$Kn]->[_TYPE_];
+ if ( $is_ternary{$type_kn} ) {
+ my $level_KK = $rLL->[$KK]->[_LEVEL_];
+ my $level_Kn = $rLL->[$Kn]->[_LEVEL_];
+ $rLL->[$KK]->[_LEVEL_] = $rLL->[$Kn]->[_LEVEL_];
+
+ # and use the ci of a terminating ':'
+ if ( $Kn == $rparent->{_Kc} ) {
+ $ci_this = $rparent->{_ci_close};
+ }
+ }
+ }
+ }
+
+ # Undo ci for a block comment followed by a closing token or , or ;
+ # provided that the parent container:
+ # - ends without ci, or
+ # - starts ci=0 and is a comma list or this follows a closing type
+ # - has a level jump
+ if (
+ $ci_this
+ && (
+ !$rparent->{_ci_close}
+ || (
+ !$rparent->{_ci_open_next}
+ && ( ( $rparent->{_comma_count} || $last_type eq ',' )
+ || $is_closing_type{$last_type} )
+ )
+ )
+ )
+ {
+ # Be sure this is a block comment
+ my $lx = $rtoken_K->[_LINE_INDEX_];
+ my $rK_range = $rlines->[$lx]->{_rK_range};
+ my $Kfirst;
+ if ($rK_range) { $Kfirst = $rK_range->[0] }
+ if ( defined($Kfirst) && $Kfirst == $KK ) {
+
+ # Look for trailing closing token
+ # [ and possibly ',' or ';' ]
+ $Kn = $self->K_next_code($KK) if ( !$Kn );
+ my $Kc = $rparent->{_Kc};
+ if (
+ $Kn
+ && $Kc
+ && (
+ $Kn == $Kc
- # We should never be using the ci of a blank token, but for
- # reference, here is the rule and code to match the old ci coding:
+ # only look for comma if -wbb=',' is set
+ # to minimize changes to existing formatting
+ || ( $rLL->[$Kn]->[_TYPE_] eq ','
+ && $want_break_before_comma
+ && $parent_container_type eq 'List' )
- # A blank after closing token has same ci as previous token,
- # Otherwise a blank has same ci as next token;
- # if ( $is_closing_type{$last_type} ) {
- # $ci_this = $ci_last;
- # }
+ # do not look ahead for a bare ';' because
+ # it changes old formatting with little benefit.
+## || ( $rLL->[$Kn]->[_TYPE_] eq ';'
+## && $parent_container_type eq 'Block' )
+ )
+ )
+ {
+ # Be sure container has a level jump
+ my $level_KK = $rLL->[$KK]->[_LEVEL_];
+ my $level_Kc = $rLL->[$Kc]->[_LEVEL_];
+ if ( $level_Kc < $level_KK ) {
+ $ci_this = 0;
+ }
+ }
+ }
+ }
+
+ $ci_next = $ci_this;
$rtoken_K->[_CI_LEVEL_] = $ci_this;
# 'next' to avoid saving last_ values for blanks and commas
next;
}
- #--------------------
- # 2. Container tokens
- #--------------------
- elsif ( $rtoken_K->[_TYPE_SEQUENCE_] ) {
+ #------------------------------------------------------------
+ # Section 3. Continuing with non-blank and non-comment tokens
+ #------------------------------------------------------------
+
+ $token = $rtoken_K->[_TOKEN_];
+
+ # Set ci values appropriate for most tokens:
+ my $ci_this = $ci_next;
+ $ci_next = $ci_next_next;
+
+ # Now change these ci values as necessary for special cases...
+
+ #----------------------------
+ # Section 4. Container tokens
+ #----------------------------
+ if ( $rtoken_K->[_TYPE_SEQUENCE_] ) {
my $seqno = $rtoken_K->[_TYPE_SEQUENCE_];
my $rtype_count = $rtype_count_by_seqno->{$seqno};
my $comma_count = $rtype_count ? $rtype_count->{','} : 0;
- #-----------------------------
- # 2.1 Opening container tokens
- #-----------------------------
+ #-------------------------------------
+ # Section 4.1 Opening container tokens
+ #-------------------------------------
if ( $is_opening_sequence_token{$token} ) {
- my $level = $rtoken_K->[_LEVEL_];
- my $container_type = EMPTY_STRING;
+ my $level = $rtoken_K->[_LEVEL_];
# Default ci values for the closing token, to be modified
# as necessary:
my $opening_level_jump =
$Kn ? $rLL->[$Kn]->[_LEVEL_] - $level : 0;
- #-----------------------------------
- # 2.1.1 Determine the container type
- #-----------------------------------
- my $is_logical = $is_container_label_type_for_ci{$last_type}
- && $is_logical_container_for_ci{$last_token};
-
- # Part 1 of optional patch to get agreement with previous ci
- # This makes almost no difference in a typical program because
- # we will seldom break within an array index.
- $is_logical ||= $type eq '[' && SET_CI_OPTION_0;
-
- if ( $token eq '(' ) {
-
- # 'foreach' and 'for' paren contents are treated as logical
- # except for C-style 'for'
- if ( $last_type eq 'k' ) {
- $is_logical ||= $last_token eq 'foreach';
-
- if ( $last_token eq 'for' ) {
- if ( $rtype_count
- && $rtype_count->{'f'} )
- {
- # C-style 'for' container will be type 'List'
- $is_logical = 0;
- }
- else {
- $is_logical = 1;
- }
- }
- }
-
- # Check for 'for' and 'foreach' loops with iterators
- elsif ( $last_type eq 'i' && defined($Kcn) ) {
- my $seqno_kcn = $rLL->[$Kcn]->[_TYPE_SEQUENCE_];
- my $type_kcn = $rLL->[$Kcn]->[_TOKEN_];
- if ( $seqno_kcn && $type_kcn eq '{' ) {
- my $block_type_kcn =
- $rblock_type_of_seqno->{$seqno_kcn};
- $is_logical ||= $block_type_kcn
- && ( $block_type_kcn eq 'for'
- || $block_type_kcn eq 'foreach' );
- }
-
- # Search backwards for 'for'/'foreach' with iterator in
- # case user is running from an editor and did not
- # include the block (fixes case 'xci.in').
- my $Km = $self->K_previous_code($KK);
- foreach ( 0 .. 2 ) {
- $Km = $self->K_previous_code($Km);
- last unless defined($Km);
- last unless $rLL->[$Km]->[_TYPE_] eq 'k';
- my $tok = $rLL->[$Km]->[_TOKEN_];
- next if $tok eq 'my';
- $is_logical ||=
- ( $tok eq 'for' || $tok eq 'foreach' );
- last;
- }
- }
-
- elsif ( $last_token eq '(' ) {
- $is_logical ||=
- $rparent->{_container_type} eq 'Logical';
- }
-
- # Pass ci though an '!'
- elsif ( $last_type eq '!' ) { $ci_this = $ci_last }
- }
-
# initialize ci_next_next to its standard value
$ci_next_next = 1;
- my $block_type = $rblock_type_of_seqno->{$seqno};
- $block_type = EMPTY_STRING unless ($block_type);
-
# Default: ci of first item of list with level jump is same as
# ci of first item of container
if ( $opening_level_jump > 0 ) {
$ci_next = $rparent->{_ci_open_next};
}
- my $no_semicolon;
- #-----------------
- # 2.1.2 Code Block
- #-----------------
+ my $container_type;
+
+ #-------------------------
+ # Section 4.1.1 Code Block
+ #-------------------------
+ my $block_type = $rblock_type_of_seqno->{$seqno};
if ($block_type) {
$container_type = 'Block';
- $no_semicolon =
+ # set default depending on block type
+ $ci_close = 0;
+
+ my $no_semicolon =
$is_block_without_semicolon{$block_type}
|| $ris_sub_block->{$seqno}
|| $last_type eq 'J';
- # set default depending on block type
- $ci_close = 0;
-
if ( !$no_semicolon ) {
# Optional fix for block types sort/map/etc which use
$ci_close_next = $ci_close;
}
- #--------------
- # 2.1.3 Ternary
- #--------------
+ #----------------------
+ # Section 4.1.2 Ternary
+ #----------------------
elsif ( $type eq '?' ) {
$container_type = 'Ternary';
if ( $rparent->{_container_type} eq 'List'
}
}
- #--------------
- # 2.1.4 Logical
- #--------------
- elsif ($is_logical) {
- $container_type = 'Logical';
+ #-------------------------------
+ # Section 4.1.3 Logical or List?
+ #-------------------------------
+ else {
+ my $is_logical = $is_container_label_type_for_ci{$last_type}
+ && $is_logical_container_for_ci{$last_token}
- $ci_next_next = 0;
- $ci_close_next = $ci_this;
+ # Part 1 of optional patch to get agreement with previous
+ # ci This makes almost no difference in a typical program
+ # because we will seldom break within an array index.
+ || $type eq '[' && SET_CI_OPTION_0;
- # Part 2 of optional patch to get agreement with previous ci
- if ( $type eq '[' && SET_CI_OPTION_0 ) {
+ if ( !$is_logical && $token eq '(' ) {
- $ci_next_next = $ci_this;
+ # 'foreach' and 'for' paren contents are treated as
+ # logical except for C-style 'for'
+ if ( $last_type eq 'k' ) {
+ $is_logical ||= $last_token eq 'foreach';
- # Undo ci at a chain of indexes or hash keys
- if ( $last_type eq '}' ) {
- $ci_this = $ci_last;
+ # C-style 'for' container will be type 'List'
+ if ( $last_token eq 'for' ) {
+ $is_logical =
+ !( $rtype_count && $rtype_count->{'f'} );
+ }
}
- }
- if ($opening_level_jump) {
- $ci_next = 0;
+ # Check for 'for' and 'foreach' loops with iterators
+ elsif ( $last_type eq 'i' && defined($Kcn) ) {
+ my $seqno_kcn = $rLL->[$Kcn]->[_TYPE_SEQUENCE_];
+ my $type_kcn = $rLL->[$Kcn]->[_TOKEN_];
+ if ( $seqno_kcn && $type_kcn eq '{' ) {
+ my $block_type_kcn =
+ $rblock_type_of_seqno->{$seqno_kcn};
+ $is_logical ||= $block_type_kcn
+ && ( $block_type_kcn eq 'for'
+ || $block_type_kcn eq 'foreach' );
+ }
+
+ # Search backwards for 'for'/'foreach' with
+ # iterator in case user is running from an editor
+ # and did not include the block (fixes case
+ # 'xci.in').
+ my $Km = $self->K_previous_code($KK);
+ foreach ( 0 .. 2 ) {
+ $Km = $self->K_previous_code($Km);
+ last unless defined($Km);
+ last unless $rLL->[$Km]->[_TYPE_] eq 'k';
+ my $tok = $rLL->[$Km]->[_TOKEN_];
+ next if $tok eq 'my';
+ $is_logical ||=
+ ( $tok eq 'for' || $tok eq 'foreach' );
+ last;
+ }
+ }
+ elsif ( $last_token eq '(' ) {
+ $is_logical ||=
+ $rparent->{_container_type} eq 'Logical';
+ }
}
- }
- #-----------
- # 2.1.5 List
- #-----------
- else {
+ #------------------------
+ # Section 4.1.3.1 Logical
+ #------------------------
+ if ($is_logical) {
+ $container_type = 'Logical';
- # Here 'List' is a catchall for none of the above types
- $container_type = 'List';
+ # Pass ci though an '!'
+ if ( $last_type eq '!' ) { $ci_this = $ci_last }
- # lists in blocks ...
- if ( $rparent->{_container_type} eq 'Block' ) {
+ $ci_next_next = 0;
+ $ci_close_next = $ci_this;
- # undo ci if another closing token follows
- if ( defined($Kcn) ) {
- my $closing_level_jump =
- $rLL->[$Kcn]->[_LEVEL_] - $level;
- if ( $closing_level_jump < 0 ) {
- $ci_close = $ci_this;
+ # Part 2 of optional patch to get agreement with
+ # previous ci
+ if ( $type eq '[' && SET_CI_OPTION_0 ) {
+
+ $ci_next_next = $ci_this;
+
+ # Undo ci at a chain of indexes or hash keys
+ if ( $last_type eq '}' ) {
+ $ci_this = $ci_last;
}
}
+
+ if ($opening_level_jump) {
+ $ci_next = 0;
+ }
}
- # lists not in blocks ...
+ #---------------------
+ # Section 4.1.3.2 List
+ #---------------------
else {
- if ( !$rparent->{_comma_count} ) {
+ # Here 'List' is a catchall for none of the above types
+ $container_type = 'List';
- $ci_close = $ci_this;
+ # lists in blocks ...
+ if ( $rparent->{_container_type} eq 'Block' ) {
- # undo ci at binary op after right paren if no
- # commas in container; fixes t027, t028
- if ( $ci_close_next != $ci_close && defined($Kcn) )
- {
- my $type_kcn = $rLL->[$Kcn]->[_TYPE_];
- if ( $bin_op_type{$type_kcn} ) {
- $ci_close_next = $ci_close;
+ # undo ci if another closing token follows
+ if ( defined($Kcn) ) {
+ my $closing_level_jump =
+ $rLL->[$Kcn]->[_LEVEL_] - $level;
+ if ( $closing_level_jump < 0 ) {
+ $ci_close = $ci_this;
}
}
}
- if ( $rparent->{_container_type} eq 'Ternary' ) {
- $ci_next = 0;
+ # lists not in blocks ...
+ else {
+
+ if ( !$rparent->{_comma_count} ) {
+
+ $ci_close = $ci_this;
+
+ # undo ci at binary op after right paren if no
+ # commas in container; fixes t027, t028
+ if ( $ci_close_next != $ci_close
+ && defined($Kcn)
+ && $bin_op_type{ $rLL->[$Kcn]->[_TYPE_] } )
+ {
+ $ci_close_next = $ci_close;
+ }
+ }
+
+ if ( $rparent->{_container_type} eq 'Ternary' ) {
+ $ci_next = 0;
+ }
}
- }
- # Undo ci at a chain of indexes or hash keys
- if ( $token ne '(' && $last_type eq '}' ) {
- $ci_this = $ci_close = $ci_last;
+ # Undo ci at a chain of indexes or hash keys
+ if ( $token ne '(' && $last_type eq '}' ) {
+ $ci_this = $ci_close = $ci_last;
+ }
}
}
- #--------------------------------
- # 2.1.6 Closing token common code
- #--------------------------------
+ #---------------------------------------
+ # Section 4.1.4 Store opening token info
+ #---------------------------------------
# Most closing tokens should align with their opening tokens.
if (
};
}
- #-----------------------------
- # 2.2 Closing container tokens
- #-----------------------------
+ #-------------------------------------
+ # Section 4.2 Closing container tokens
+ #-------------------------------------
else {
+
my $seqno_test = $rparent->{_seqno};
if ( $seqno_test ne $seqno ) {
&& Fault("stack error: $seqno_test != $seqno\n");
}
- # use the values set by the opening token
+ # Use ci_this, ci_next values set by the matching opening token:
$ci_this = $rparent->{_ci_close};
$ci_next = $rparent->{_ci_close_next};
-
my $ci_open_old = $rparent->{_ci_open};
+
+ # Then pop the stack and use the parent ci_next_next value:
if ( @{$rstack} ) {
$rparent = pop @{$rstack};
$ci_next_next = $rparent->{_ci_next_next};
DEVEL_MODE && Fault("empty stack - shouldn't happen\n");
}
- # Undo ci at a closing token followed by a closing token. Goal
- # is to keep formatting independent of the existance of a
+ # Fix: undo ci at a closing token followed by a closing token.
+ # Goal is to keep formatting independent of the existance of a
# trailing comma or semicolon.
if ( $ci_this > 0 && !$ci_open_old && !$rparent->{_ci_close} ) {
my $Kc = $rparent->{_Kc};
}
}
- #------------
- # 3. Comments
- #------------
- elsif ( $type eq '#' ) {
-
- # If at '#' in ternary before a ? or :, use that level to make
- # the comment line up with the next ? or : line. (see c202/t052)
- # i.e. if a nested ? follows, we increase the '#' level by 1, and
- # if a nested : follows, we decrease the '#' level by 1.
- # This is the only place where this sub changes a _LEVEL_ value.
- my $Kn;
- my $parent_container_type = $rparent->{_container_type};
- if ( $parent_container_type eq 'Ternary' ) {
- $Kn = $self->K_next_code($KK);
- if ($Kn) {
- my $type_kn = $rLL->[$Kn]->[_TYPE_];
- if ( $is_ternary{$type_kn} ) {
- my $level_KK = $rLL->[$KK]->[_LEVEL_];
- my $level_Kn = $rLL->[$Kn]->[_LEVEL_];
- $rLL->[$KK]->[_LEVEL_] = $rLL->[$Kn]->[_LEVEL_];
-
- # and use the ci of a terminating ':'
- if ( $Kn == $rparent->{_Kc} ) {
- $ci_this = $rparent->{_ci_close};
- }
- }
- }
- }
-
- # Undo ci for a block comment followed by a closing token or , or ;
- # provided that the parent container:
- # - ends without ci, or
- # - starts ci=0 and is a comma list or this follows a closing type
- # - has a level jump
- if (
- $ci_this
- && (
- !$rparent->{_ci_close}
- || (
- !$rparent->{_ci_open_next}
- && ( ( $rparent->{_comma_count} || $last_type eq ',' )
- || $is_closing_type{$last_type} )
- )
- )
- )
- {
- # Be sure this is a block comment
- my $lx = $rtoken_K->[_LINE_INDEX_];
- my $rK_range = $rlines->[$lx]->{_rK_range};
- my $Kfirst;
- if ($rK_range) { $Kfirst = $rK_range->[0] }
- if ( defined($Kfirst) && $Kfirst == $KK ) {
-
- # Look for trailing closing token
- # [ and possibly ',' or ';' ]
- $Kn = $self->K_next_code($KK) if ( !$Kn );
- my $Kc = $rparent->{_Kc};
- if (
- $Kn
- && $Kc
- && (
- $Kn == $Kc
-
- # only look for comma if -wbb=',' is set
- # to minimize changes to existing formatting
- || ( $rLL->[$Kn]->[_TYPE_] eq ','
- && $want_break_before_comma
- && $parent_container_type eq 'List' )
-
- # do not look ahead for a bare ';' because
- # it changes old formatting with little benefit.
-## || ( $rLL->[$Kn]->[_TYPE_] eq ';'
-## && $parent_container_type eq 'Block' )
- )
- )
- {
-
- # Be sure container has a level jump
- my $level_KK = $rLL->[$KK]->[_LEVEL_];
- my $level_Kc = $rLL->[$Kc]->[_LEVEL_];
- if ( $level_Kc < $level_KK ) {
- $ci_this = 0;
- }
- }
- }
- }
-
- $ci_next = $ci_this;
- $rtoken_K->[_CI_LEVEL_] = $ci_this;
-
- # 'next' to avoid saving last_ values for blanks and commas
- next;
- }
-
- #-------------------------
- # 4. Semicolons and Labels
- #-------------------------
+ #---------------------------------
+ # Section 5. Semicolons and Labels
+ #---------------------------------
# The next token after a ';' and label (type 'J') starts a new stmt
# The ci after a C-style for ';' (type 'f') is handled similarly.
# TODO: There is type 'f' redundant coding in sub respace which can
if ( $is_closing_type{$last_type} ) { $ci_this = $ci_last }
}
- #------------
- # 5. Keywords
- #------------
+ #--------------------
+ # Section 6. Keywords
+ #--------------------
# Undo ci after a format statement
elsif ( $type eq 'k' ) {
if ( substr( $token, 0, 6 ) eq 'format' ) {
}
}
- #----------
- # 6. Commas
- #----------
+ #------------------
+ # Section 7. Commas
+ #------------------
# A comma and the subsequent item normally have ci undone
# unless ci has been set at a lower level
elsif ( $type eq ',' ) {
}
}
- #-------------------------
- # 7. Hanging side comments
- #-------------------------
+ #---------------------------------
+ # Section 8. Hanging side comments
+ #---------------------------------
# Treat hanging side comments like blanks
elsif ( $type eq 'q' && $token eq EMPTY_STRING ) {
$ci_next = $ci_this;
next;
}
- #-----------------------------------------------------------------
- # Development test: ci_this should match the ci from the tokenizer
- # except where the new value makes an improvement.
- #-----------------------------------------------------------------
+ # Save debug info if requested
DEBUG_SET_CI && do {
my $seqno = $rtoken_K->[_TYPE_SEQUENCE_];
my $block_type;
$block_type = $rblock_type_of_seqno->{$seqno} if ($seqno);
$block_type = EMPTY_STRING unless ($block_type);
- if ( !defined($block_type) ) { $block_type = EMPTY_STRING }
my $ptype = $rparent->{_container_type};
my $pname = $ptype;
EOM
};
+ #----------------------------------
+ # Store the ci value for this token
+ #----------------------------------
$rtoken_K->[_CI_LEVEL_] = $ci_this
# do not store in hybrid testing mode
if ( !$ci_comments_only );
- # Remember last nonblank, non-comment token info
+ # Remember last nonblank, non-comment token info for the next pass
$ci_last = $ci_this;
$last_token = $token;
$last_type = $type;
- }
+ } ## End main loop over tokens
- # End main loop
+ #----------------------
+ # Post-loop operations:
+ #----------------------
# if the logfile is saved, we need to save the leading ci of
# each old line of code.
projects / perltidy.git / commitdiff