Fix trailing whitespace in scripts and misc. files

Tools/Scripts/VCSUtils.pm

 # Copyright (C) 2007, 2008, 2009, 2010, 2011, 2012, 2013 Apple Inc.  All rights reserved.
 # Copyright (C) 2009, 2010 Chris Jerdonek (chris.jerdonek@gmail.com)
 # Copyright (C) 2010, 2011 Research In Motion Limited. All rights reserved.
 # Copyright (C) 2012 Daniel Bates (dbates@intudata.com)
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions
 # are met:
 #
 # 1.  Redistributions of source code must retain the above copyright
-#     notice, this list of conditions and the following disclaimer. 
+#     notice, this list of conditions and the following disclaimer.
 # 2.  Redistributions in binary form must reproduce the above copyright
 #     notice, this list of conditions and the following disclaimer in the
-#     documentation and/or other materials provided with the distribution. 
+#     documentation and/or other materials provided with the distribution.
 # 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
 #     its contributors may be used to endorse or promote products derived
-#     from this software without specific prior written permission. 
+#     from this software without specific prior written permission.
 #
 # THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 # DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
 # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
@@ skipping 421 matching lines @@
 {
     my ($colors, $string) = @_;
 
     if (-t STDOUT) {
         return colored([$colors], $string);
     } else {
         return $string;
     }
 }
 
-sub adjustPathForRecentRenamings($) 
-{ 
-    my ($fullPath) = @_; 
- 
+sub adjustPathForRecentRenamings($)
+{
+    my ($fullPath) = @_;
+
     $fullPath =~ s|WebCore/webaudio|WebCore/Modules/webaudio|g;
     $fullPath =~ s|JavaScriptCore/wtf|WTF/wtf|g;
     $fullPath =~ s|test_expectations.txt|TestExpectations|g;
 
-    return $fullPath; 
-} 
+    return $fullPath;
+}
 
 sub canonicalizePath($)
 {
     my ($file) = @_;
 
     # Remove extra slashes and '.' directories in path
     $file = File::Spec->canonpath($file);
 
     # Remove '..' directories in path
     my @dirs = ();
@@ skipping 691 matching lines @@
     # Notice, we keep processing until we hit end-of-file or some
     # line that does not resemble $svnPropertyStartRegEx, such as
     # the empty line that precedes the start of the binary contents
     # of a patch, or the start of the next diff (e.g. "Index:").
     my $propertyHashRef;
     while (defined($_) && /$svnPropertyStartRegEx/) {
         ($propertyHashRef, $_) = parseSvnProperty($fileHandle, $_);
         if ($propertyHashRef->{name} eq "svn:executable") {
             # Notice, for SVN properties, propertyChangeDelta is always non-zero
             # because a property can only be added or removed.
-            $footer{executableBitDelta} = $propertyHashRef->{propertyChangeDelta};   
+            $footer{executableBitDelta} = $propertyHashRef->{propertyChangeDelta};
         }
     }
 
     return(\%footer, $_);
 }
 
 # Parse the next SVN property from the given file handle, and advance the handle so the last
 # line read is the first line after the property.
 #
 # This subroutine dies if the first line is not a valid start of an SVN property,
@@ skipping 318 matching lines @@
 # this subroutine because the diff(1) command is greedy when matching
 # lines. A new ChangeLog entry with the same date and author as the
 # previous will match and cause the diff to have lines of starting
 # context.
 #
 # This subroutine has unit tests in VCSUtils_unittest.pl.
 #
 # Returns $changeLogHashRef:
 #   $changeLogHashRef: a hash reference representing a change log patch.
 #     patch: a ChangeLog patch equivalent to the given one, but with the
-#            newest ChangeLog entry inserted at the top of the file, if possible.              
+#            newest ChangeLog entry inserted at the top of the file, if possible.
 sub fixChangeLogPatch($)
 {
     my $patch = shift; # $patch will only contain patch fragments for ChangeLog.
 
     $patch =~ s|test_expectations.txt:|TestExpectations:|g;
 
     $patch =~ /(\r?\n)/;
     my $lineEnding = $1;
     my @lines = split(/$lineEnding/, $patch);
 
@@ skipping 123 matching lines @@
 # This subroutine has unit tests in VCSUtils_unittest.pl.
 sub generatePatchCommand($)
 {
     my ($passedArgsHashRef) = @_;
 
     my $argsHashRef = { # Defaults
         ensureForce => 0,
         shouldReverse => 0,
         options => []
     };
-    
+
     # Merges hash references. It's okay here if passed hash reference is undefined.
     @{$argsHashRef}{keys %{$passedArgsHashRef}} = values %{$passedArgsHashRef};
-    
+
     my $ensureForce = $argsHashRef->{ensureForce};
     my $shouldReverse = $argsHashRef->{shouldReverse};
     my $options = $argsHashRef->{options};
 
     if (! $options) {
         $options = [];
     } else {
         $options = [@{$options}]; # Copy to avoid side effects.
     }
 
@@ skipping 305 matching lines @@
 
     die "$fullPath: unexpected size of the first chunk (expected $binaryChunkExpectedSize but was $binaryChunkActualSize" if ($binaryChunkType eq "literal" and $binaryChunkExpectedSize != $binaryChunkActualSize);
     die "$fullPath: unexpected size of the second chunk (expected $reverseBinaryChunkExpectedSize but was $reverseBinaryChunkActualSize" if ($reverseBinaryChunkType eq "literal" and $reverseBinaryChunkExpectedSize != $reverseBinaryChunkActualSize);
 
     return ($binaryChunkType, $binaryChunk, $reverseBinaryChunkType, $reverseBinaryChunk);
 }
 
 sub readByte($$)
 {
     my ($data, $location) = @_;
-    
-    # Return the byte at $location in $data as a numeric value. 
+
+    # Return the byte at $location in $data as a numeric value.
     return ord(substr($data, $location, 1));
 }
 
 # The git binary delta format is undocumented, except in code:
 # - https://github.com/git/git/blob/master/delta.h:get_delta_hdr_size is the source
 #   of the algorithm in decodeGitBinaryPatchDeltaSize.
 # - https://github.com/git/git/blob/master/patch-delta.c:patch_delta is the source
 #   of the algorithm in applyGitBinaryPatchDelta.
 sub decodeGitBinaryPatchDeltaSize($)
 {
     my ($binaryChunk) = @_;
-    
+
     # Source and destination buffer sizes are stored in 7-bit chunks at the
     # start of the binary delta patch data.  The highest bit in each byte
     # except the last is set; the remaining 7 bits provide the next
     # chunk of the size.  The chunks are stored in ascending significance
     # order.
     my $cmd;
     my $size = 0;
     my $shift = 0;
     for (my $i = 0; $i < length($binaryChunk);) {
         $cmd = readByte($binaryChunk, $i++);
         $size |= ($cmd & 0x7f) << $shift;
         $shift += 7;
         if (!($cmd & 0x80)) {
             return ($size, $i);
         }
     }
 }
 
 sub applyGitBinaryPatchDelta($$)
 {
     my ($binaryChunk, $originalContents) = @_;
-    
+
     # Git delta format consists of two headers indicating source buffer size
     # and result size, then a series of commands.  Each command is either
     # a copy-from-old-version (the 0x80 bit is set) or a copy-from-delta
     # command.  Commands are applied sequentially to generate the result.
     #
     # A copy-from-old-version command encodes an offset and size to copy
     # from in subsequent bits, while a copy-from-delta command consists only
     # of the number of bytes to copy from the delta.
 
     # We don't use these values, but we need to know how big they are so that
@@ skipping 108 matching lines @@
         @result = split(/[\r\n]+/, $diffOutput);
     }
 
     chdir $cwd;
 
     return @result;
 }
 
 
 1;