I guess what's causing you problems is that on some lines, there's only a carriage return at the end of line (in your example, it's those lines with the sequence data).

So what happens is that all those lines (up to the next proper newline (i.e. the one used on your platform)) are being read in as one line; and when you print that string, the carriage returns reposition the terminal cursor to the beginning of the line, so most of data is overprinted...   The "weird" result you're seeing is what remains.

The following snippet demonstrates the effect (note the "\r" at the end of the substrings):

my $newline = 
  "TTTATGCACTCATGTTTAGACATATTTCCTACACCCATATTTGAAGACCA\r"
. "... other lines (overprinted) ...\r"
. "TAGATTCTGTAAACTGTGTCCATTTCTGTGCCTATTTACTTGGTATTTGT\r"
. "TAACTCTTAGTACACATAAGTTTACGTACC\r";

print "\$newline is: $newline\n";  # (this is your debug print)
[download]

In other words, you have to make sure that - after cut-n-pasting from one platform to another - the resulting lines are all conforming to the same newline style (preferably the one being used by your OS :)

Several tools can help here, for example dos2unix, unix2dos, ..., or Perl's tr///, or s/// (e.g. tr/\r/\n/). Some editors can do auto-conversions, too. But you have to fix things before you process the data with your program.   Good luck.

#!/usr/bin/perl

=head1 NAME

space-hist  -- tabulate histogram of whitespace patterns

=head1 SYNOPSIS

space-hist file.name

=head1 DESCRIPTION

This will read the full content of the given text file into memory,
tokenize the data on whitespace, and then count how many times each
distinct whitespace string occurs.  The various whitespace string
patterns are listed on STDOUT as strings of hex codes, with the
frequency of occurrence for each, in descending order of frequency.

=cut

use strict;

die "Usage: $0 file.txt\n" unless ( @ARGV == 1 and -f $ARGV[0] );

$/ = undef; # slurp mode
open( IN, "<", $ARGV[0] ) or die "open failed for $ARGV[0]: $!";
$_ = <IN>;

@_ = split /(\s+)/;

my %whitespace;
for my $tkn ( @_ ) {
    next unless ( $tkn =~ /^\s+$/ );
    my $wshex = join " ", map { sprintf "%02x", ord($_) } split //, $t
+kn;
    $whitespace{$wshex}++;
}

print "Whitespace tokens found in $ARGV[0]:\n";
for ( sort {$whitespace{$b} <=> $whitespace{$a}} keys %whitespace ) {
    printf "%4d %s\n", $whitespace{$_}, $_;
}
[download]

The point is: you either need to adapt your script to the range of whitespace patterns that actually occur in your data, or else you need to doctor your data so that its whitespace patterns conform to the limitations of your script.

Looking at what's in the data is only the first step, and it's totally worthwhile to make that step as thorough as possible. BTW, using my script as input to itself, I get the following (because I created it with emacs on macosx):

$ space-hist space-hist
Whitespace tokens found in space-hist:
 125 20
  12 0a 0a
  11 0a
   4 0a 20 20 20 20
   2 20 20
[download]

But since I'm here anyway, I've got a random guess: something else is setting $/ in your program, messing up <> and causing you to get multiple lines in the (oddly named) $newline variable. I don't see how else that line could print two lines of text - but I do note that the code you posted isn't what produced the output you show... Maybe something changed aside from commenting some stuff out?

-sam