From 49115fe546ac96be9049cb1b0385c14a0b8881cf Mon Sep 17 00:00:00 2001
From: Andrew Edmunds <andrew.edmunds@yahoo.com.au>
Date: Sun, 6 Oct 2013 10:04:51 +1000
Subject: [PATCH] English translations of German comments

This patch adds English translations of German comments in the code of
storeBackup.pl v3.4.2. Translations are courtesy of Google Translate.
Be warned, some of them may not be correct. I hope they will be of some use
to English speakers attempting to make sense of this code.
---
 bin/storeBackup.pl | 196 ++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 173 insertions(+), 23 deletions(-)

diff --git a/bin/storeBackup.pl b/bin/storeBackup.pl
index 22b7c2f..c9dc2d1 100755
--- a/bin/storeBackup.pl
+++ b/bin/storeBackup.pl
@@ -17,6 +17,10 @@
 #   You should have received a copy of the GNU General Public License
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
+#>Comments in English starting with "#>" are machine translations of the
+#>preceeding comment in German.  Be warned, some of these may not be
+#>correct. I hope they will be of some use to English speakers attempting
+#>to make sense of this code.
 
 require SDBM_File;
 require Tie::Hash;
@@ -39,6 +43,7 @@ sub libPath
     my $dir;
 
     # Falls Datei selbst ein symlink ist, solange folgen, bis aufgelöst
+    #>If file is a symlink, follow until resolved
     if (-f $file)
     {
 	while (-l $file)
@@ -64,7 +69,7 @@ sub libPath
 	exit 1;
     }
 
-    $dir .= "/../lib";           # Pfad zu den Bibliotheken
+    $dir .= "/../lib";           # Pfad zu den Bibliotheken #>Library path
     my $oldDir = `/bin/pwd`;
     chomp $oldDir;
     if (chdir $dir)
@@ -85,9 +90,10 @@ sub splitFileDir
     my $name = shift;
 
     return ('.', $name) unless ($name =~/\//);    # nur einfacher Dateiname
-
+                                                  #>only simple file name
     my ($dir, $file) = $name =~ /^(.*)\/(.*)$/s;
     $dir = '/' if ($dir eq '');                   # gilt, falls z.B. /filename
+                                                  #>applies if e.g. /filename
     return ($dir, $file);
 }
 my ($req, $prog) = &libPath($0);
@@ -114,6 +120,7 @@ no warnings 'newline';    # no warning for stat of files with newline
 #
 #
 #Aus dem Source für "xargs" geht hervor:
+#>From the source for "xargs" stating:
 #
 #  orig_arg_max = ARG_MAX - 2048; /* POSIX.2 requires subtracting 2048. */
 #  arg_max = orig_arg_max;
@@ -122,8 +129,11 @@ $main::stbuMd5Exec = "$req/stbuMd5Exec.pl";
 $main::stbuMd5cp = "$req/stbuMd5cp.pl";
 $main::endOfStoreBackup = 0;
 $main::execParamLength = 4 * 1024;      # Default Wert, sehr niedrig angesetzt
+                                        #>Default value, set very low
 $main::minCopyWithFork = 1024**2;       # alles was <= ist, wird in perl
                                         # kopiert, was > ist, mit fork
+                                        #>everything <= is copied in perl
+                                        #>everything > with fork
 my (%execParamLength) = ('AIX' => 22 * 1024,
 			 'Linux' => 62 * 1024);
 $main::sourceDir = '';                  # set for main::COMRESS
@@ -2153,6 +2163,7 @@ $CheckPar->check('-argv' => \@ARGV,
                  );
 
 # Auswertung der Parameter
+#>Evaluate parameters
 my $help = $CheckPar->getOptWithoutPar('help');
 
 die "$FullHelp" if $help;
@@ -2655,6 +2666,9 @@ if ($@)
 
 # OS-Typ feststellen, um ARG_MAX zu setzen
 # Default wird vorsichtshalber auf 4 KB gesetzt!
+#>Detect OS type to set ARG_MAX
+#>Default is set to 4 KB as a precaution!
+
 {
     my $uname = forkProc->new('-exec' => 'uname',
 			      '-outRandom' => "$tmpdir/uname-",
@@ -2780,6 +2794,9 @@ my $startDate = dateTools->new();
 # (neueste zuletzt). Das ist wichtig, damit ctime etc. einer zu
 # sichernden Datei auch den neuesten archivierten Daten verglichen
 # wird.
+#>Identify other backup series and sort in the correct order
+#>(most recent last). This is important so that ctime, etc. of a
+#>backed up file will be compared to the latest archived data.
 #
 
 # consider last of backup of all series if not specified
@@ -2799,6 +2816,7 @@ if (@otherBackupSeries > 0)
     my (@obd, $d);
 
     # Verzeichnisse ermitteln
+    #>Determine directories
     foreach $d (@otherBackupSeries)
     {
 	if ($d =~ /\A(all|\d+|\d+-\d+):(.*)/)
@@ -3004,6 +3022,7 @@ $main::stat = Statistic->new('-startDate' =>
 #
 # exception- und include- Liste überprüfen und evaluieren
 # + checkBlocksRule 
+#>Check exception and include list and evaluate checkBlocksRule
 #
 my (@exceptDirs) = &evalExceptionList($exceptDirs, $sourceDir,
 				   'exceptDir', 'excluding', $prLog);
@@ -3035,19 +3054,24 @@ $prLog->print('-kind' => 'I',
 
 #
 # überprüfen, ob Backup Target im Backup Source Tree liegt
+#>Check if backup target is in the backup source tree
 #
 my $targetInSource = 0;
-if (&::isSubDir($sourceDir, $targetDir))    # liegt drin!
+if (&::isSubDir($sourceDir, $targetDir))    # liegt drin! #>it is!
 {
     $targetInSource = 1;                 # Annahme: es gibt keine Ausnahme
     if (@exceptDirs > 0)                 # testen, ob vielleicht im vom
     {                                    # Backup ausgenommenen Tree
+                                         #>Assumption: there is no exception to
+                                         #>test if maybe excluded from the
+                                         #>backup tree
 	my $e;
 	foreach $e (@exceptDirs)
 	{
 	    if (&::isSubDir($e, $targetDir))
 	    {
 		$targetInSource = 0;     # doch Ausnahme gefunden
+                                         #>but found exception
 		$prLog->print('-kind' => 'I',
 			      '-str' =>
 			      ["target directory <$targetDir> is in " .
@@ -3108,6 +3132,7 @@ if (@exceptDirs and @includeDirs and not exists $suppressWarning{'excDir'})
 
 #
 # lock file überprüfen
+#>lock file check
 #
 ::checkLockFile($lockFile, $prLog);
 
@@ -3120,6 +3145,7 @@ foreach $et (split(//, $exceptTypes || ""))
 
 #
 # precommand ausführen
+#>run precommand
 #
 if (defined $precommand)
 {
@@ -3161,6 +3187,7 @@ if (defined $precommand)
 
 #
 # Erzeugen der benötigten Objekte
+#>Generate the required objects
 #
 my $adminDirs = adminDirectories->new('-targetDir' => $targetDir,
 				      '-checkSumFile' => $checkSumFile,
@@ -3221,6 +3248,7 @@ my $setResetDirTimes =
 
 my $prLog2 = undef;
 if ($logInBackupDir)      # auch in BackupDirs herinloggen
+                          # heritable log in BackupDirs
 {
     $logInBackupDirFileName =
 	$adminDirs->getAktDir() . "/$logInBackupDirFileName",
@@ -3346,7 +3374,7 @@ if ($saveRAM)
 
 
 # signal handling
-(@main::cleanup) =      # Objekte verfügbar machen
+(@main::cleanup) =      # Objekte verfügbar machen  #>Make objects available
     ($prLog, 0, $oldFilename, $aktFilename, $parForkCopy, $parForkCompr, $tmpdir,
      $setResetDirTimesFile, $lockFile, $stbuEXCLfilename, $stbuEXCLRECfilename);
 $SIG{INT} = \&cleanup;
@@ -3409,13 +3437,13 @@ $main::tinyWaitScheduler = tinyWaitScheduler->new('-firstFast' => 1,
 
 
 $scheduler->normalOperation();   # die eigentliche Verarbeitung
-
+                                 #>the actual processing
 $setResetDirTimes->writeTimes(); # set atime, mtime for directories
 
 $aktFilename->closeInfoFile();
 $oldFilename->readDBMFilesSize();
 $oldFilename->delDBMFiles();     # dbm files löschen
-
+                                 #>delete dbm files
 if ($stbuEXCLfilename)
 {
 #    untie %main::MARK_DIR_Cache;
@@ -3437,12 +3465,14 @@ if ($stbuINCLRECfilename)
 
 #
 # jetzt noch alte Backups löschen
+#>now delete some old backups
 #
 $delOld->deleteBackups();
 
 
 #
 # postcommand ausführen
+#>Run post-command
 #
 
 if (defined $postcommand)
@@ -3483,6 +3513,7 @@ if (defined $postcommand)
 }
 
 # lock file löschen
+#>Delete lock file
 if ($lockFile and $unlockBeforeDel)
 {
     $prLog->print('-kind' => 'I',
@@ -3493,6 +3524,7 @@ if ($lockFile and $unlockBeforeDel)
 
 
 # Größe von .md5CheckSum-Datei noch für Statistik berücksichtigen
+#>Record size of .md5CheckSum file for statistics
 $main::stat->setSizeMD5CheckSum($adminDirs->getAktInfoFile(),
 				$compressMD5File);
 $main::stat->setUsedSizeQueues($fifoCopy->getMaxUsedLength(),
@@ -3500,6 +3532,7 @@ $main::stat->setUsedSizeQueues($fifoCopy->getMaxUsedLength(),
 $main::stat->print('-exTypes' => \%exTypes);
 
 # lock file löschen
+#>Delete lock file
 if ($lockFile)
 {
     $prLog->print('-kind' => 'I',
@@ -3509,6 +3542,7 @@ if ($lockFile)
 
 if ($compressLogInBackupDir)             # log file im BackupDir noch
 {                                        # komprimieren
+                                         #>log file or compress the backupDir
     $prLog->sub('-prLogs' => [$prLog2]);
     my $compressLog = forkProc->new('-exec' => 'bzip2',
 				    '-param' => [$logInBackupDirFileName],
@@ -3601,11 +3635,13 @@ sub cleanup
     unless ($onlyLateLinkCheck)
     {
 	# Dateien schließen, aufräumen
+        #>Close files, clean up
 	$aktFilename->delInfoFile();
-	$oldFilename->delDBMFiles();     # dbm files löschen
+	$oldFilename->delDBMFiles();     # dbm files löschen  #>delete dbm files
 	unlink $setResetDirTimesFile;
 
 	# laufende Prozesse abschießen
+        #>Kill runnning processes
 	$parForkCopy->signal('-value' => 2);
 	$parForkCompr->signal('-value' => 2);
 
@@ -3635,10 +3671,12 @@ sub cleanup
 ##################################################
 #
 # exception-Liste überprüfen und evaluieren
+#>Check exception list and evaluate
 #
 sub evalExceptionList
 {
     my $exceptDirs = shift;   # Pointer auf Liste mit Ausnahme-Directories
+                              #>Pointer to the list of exception directories
     my $sourceDir = shift;
     my $exceptDir = shift;
     my $excluding = shift;
@@ -3655,6 +3693,7 @@ sub evalExceptionList
 	$_e =~ s/(\s)/\\$1/g;
 	my (@a) = ($_e);
 	my (@e) = <@a>;        # wildcards auflösen, rechts muss Array stehen
+                               #>Dissolve wildcards, must be right array
 	unless (@e)            # this happens if path does not exist
 	{
 	    $prLog->print('-kind' => $kind,
@@ -3664,6 +3703,7 @@ sub evalExceptionList
 	    $flag = 1;
 	}
 	(@a) = ();             # wird jetzt zum Aufsammeln verwendet
+                               #>is now used for collecting
 	my $e1;
 	foreach $e1 (@e)
 	{
@@ -4170,6 +4210,8 @@ sub calcBlockMD5Sums
 
 ##################################################
 # schreibt neue Meta-Informationen in dbms + .md5CheckSum
+#>Writes new meta-information in dbms + .md5CheckSum
+
 package aktFilename;
 
 sub new
@@ -4363,6 +4405,7 @@ sub setDBMmd5
 
 ########################################
 # für normale Dateien
+#>For normal files
 sub store
 {
     my $self = shift;
@@ -4382,6 +4425,8 @@ sub store
 		    '-mode'        => undef,
 		    '-storeInDBM'  => 1      # Default: speichern,
 		                             #        0 = nicht speichern
+                                             #>Default: save,
+                                             #>       0 = don't save
 		    );
 
     &::checkObjectParams(\%params, \@_, 'aktFilename::store',
@@ -4412,6 +4457,7 @@ sub store
 				  0, $f)
 	    unless exists $$DBMmd5{$md5pack};
     }	                            # $backupDirIndex ist immer 0
+                                    #>$backupDirIndex is always 0
 
     $self->{'writeCheckSumFile'}->write('-filename' => $filename,
 					'-md5sum' => $md5sum,
@@ -4660,17 +4706,27 @@ sub new
     my $class = shift;
 
     my (%params) = ('-dir'            => undef, # zu durchsuchendes directory
+                                                #>directory to be searched
 		    '-adminDirs'      => undef, # Objekt mit Infos von
 		                                # Verzeichnissen
+                                                #>object with information from
+                                                #>directories
 		    '-oldFilename'    => undef, # Objekt mit alten DBMs etc.
+                                                #>object with old DBMs etc.
 		    '-aktFilename'    => undef, # Objekt für neue Meta Infos
+                                                #>object for new meta info
 		    '-aktDir'         => undef, # zu sicherndes Directory
+                                                #>backup directory
 		    '-followLinks'    => 0,     # Tiefe, bis zu der symlinks
 		                                # gefolgt werden soll
+                                                #>max depth to follow symlinks
 		    '-exceptDirs'     => [],    # Ausnahmeverzeichnisse
+                                                #>except directories
 		    '-includeDirs'    => [],    # only include these dirs
 		    '-postfix'        => undef, # Postfix, der nach Kompr.
 		                                # angehängt werden soll
+                                                #>postfix, according to 
+                                                #>compression to be used
 		    '-includeRule'    => undef,
 		    '-exceptRule'     => undef,
 		    '-checkBlocksRule' => undef,
@@ -4685,6 +4741,7 @@ sub new
 		    '-prLogError'     => 'E',
 		    '-prLogWarn'      => 'W',
 		    '-exitIfError'    => 1,      # Errorcode bei Fehler
+                                                 #>errorode on error
 		    '-ignoreReadError' => 'no',
 		    '-ignoreTime'     => 'none',
 		    '-printDepth'     => undef
@@ -4717,7 +4774,7 @@ sub new
     $self->{'aktInfoFile'} = $params{'-adminDirs'}->getAktInfoFile();
 
     $self->{'md5Fork'} = undef;      # es läuft kein paralleles md5sum
-
+                                     #>run with no parallel md5sum
     if ($self->{'writeExcludeLog'})
     {
 	my $wcl = $self->{'writeExcludeLog'};
@@ -4735,6 +4792,7 @@ sub new
 
 ########################################
 # liefert Basisverzeichnis, dazu relativen Dateinamen und Filetyp
+#>Provides base directory to relative file name and file type
 sub next
 {
     my $self = shift;
@@ -4760,6 +4818,7 @@ sub next
 
     my $md5 = shift @{$self->{'md5'}};
     # $f zerlegen in vorgegebenen Teil und relativen
+    #>$f split into predetermined partial and relative
     my $dir = $self->{'dir'};
     my $file = &::substractPath($f, $dir);
 
@@ -4769,10 +4828,13 @@ sub next
 
 ########################################
 # wird von %inProgress in Scheduler::normalOperation benötigt
+#>needed by %inProgress in Scheduler::normalOperation
+
 sub pushback
 {
     my $self = shift;
     my $list = shift;     # Liste mit Listen von ($dir, $file, $md5, $types)
+                          #>List of lists of ($dir, $file, $md5, $types)
     my $prLog = shift;
     my $debug = shift;
 
@@ -4821,6 +4883,7 @@ sub readDir
 
 
     # MD5 läuft, wenn möglich MD5 Summen vom Parallelprozess holen
+    #>MD5 is running, if possible get MD5 sums from the parallel process
     if ($self->{'md5Fork'} and
         not $self->{'md5Fork'}->processRuns())
     {
@@ -4835,12 +4898,16 @@ sub readDir
         foreach $l (@$stdout)
         {
             if ($l =~ /\A\\/)  # "\" am Zeilenanfang -> es wird gequotet
+                               #>"\" at start of line -> it will ??gequotet??
             {
                 $l =~ s/\\n/\n/g;   # "\n" im Namen wird von md5sum zu
                                     # "\\n" gemacht,
                                     # zurückkonvertieren!
+                                    #>"\ n" in the name of md5sum is converted
+                                    #>to "\\n", convert back!
                 $l =~ s/\\\\/\\/og; # Backslash
                 $l =~ s/\A\\//;     # "\\" am Zeilenanfang entfernen
+                                    #>remove "\\" at the beginning of the line
 
             }
             my ($md5, $f) = $l =~ /\A(\w+)\s+(.*)/s;
@@ -4848,22 +4915,26 @@ sub readDir
             push @md5, $md5;
             push @types, 'f';
         }
-        $self->{'md5Fork'} = undef;  # job ist fertig
+        $self->{'md5Fork'} = undef;  # job ist fertig  #>job is finished
     }
 
     # Neuen MD5 Lauf starten wenn möglich
+    #>If possible, start new MD5 running
     if (not $self->{'md5Fork'})
     {
         my(@calcMD5) = ();
 
 	# Directory einlesen
+        #>Read directory
         $self->recursiveReadDir::readDir();
 
 	# Eingelesene Dateien in $self->{'files'} filtern
+        #>Filtering download files in $self->{'files'}
         my ($f, $t, $i);
         my $dir = $self->{'dir'};     # zu durchsuchendes Directory
-
+                                      #>directory to be searched
         my $aktDir = $self->{'aktDir'};   # aktuelles Backupverzeichnis
+                                          #>current backup directory
 	for ($i = 0 ; $i < @{$self->{'files'}} ; $i++)
 	{
 	    $f = $self->{'files'}[$i];
@@ -4965,6 +5036,7 @@ sub readDir
 	    }
 
             # Nicht plain-file benötigt kein MD5
+            #>Not regular file, does not require an MD5
 	    if ($t ne 'f')
 	    {
 		push @files, $f;
@@ -4976,6 +5048,7 @@ sub readDir
 
 	    #
 	    # ab hier ist alles nur noch plain file (in for Schleife)
+            #>From here everything is just regular file (in for loop)
 	    #
 	    my ($oldCompr, $oldCtime, $oldMtime, $oldSize, $md5sum);
 	    my $n = ($oldCompr, $oldCtime, $oldMtime, $oldSize, $md5sum) =
@@ -5039,6 +5112,8 @@ sub readDir
 	    # plain files, no blocked files
 	    if ($n == 0)    # nicht im Hash gefunden (aus Datei .md5CheckSums
 	    {               # -> näher untersuchen!
+                            #>not found in the hash (from file .md5CheckSums)
+                            #> -> examine closer!
                 $prLog->print('-kind' => 'I',
                               '-str' =>
                               ["Checking $relFileName [new]"]) if $verbose;
@@ -5100,10 +5175,12 @@ sub readDir
 	    #
 	    # übrig: plain files, die sich gegenüber dem letzten Backup
 	    # nicht verändert haben
+            #>left: regular files that have not changed since the last backup
 	    #
 
             # mit md5 Summe über dbm(md5) gehen, dadurch
             # Doppelte vermeiden
+            #>go with md5 sum of dbm(md5), thus avoiding double
             push @files, $f;
             push @md5, $md5sum;
             push @types, 'f';
@@ -5112,6 +5189,7 @@ sub readDir
 
         # Parallelprozess starten,
         # MD5 Summen für @calcMD5 berechnen
+        #>Start parallel process, calculate MD5 sums for @calcMD5
         if (@calcMD5 > 0)
         {
             $self->{'md5Fork'} = forkMD5->new('-param' => [@calcMD5],
@@ -5125,6 +5203,8 @@ sub readDir
     # Falls noch ein Parallelprozess läuft, sicherstellen dass readDir
     # erneut aufgerufen wird auch wenn es jetzt nichts zurückgegeben
     # hat.
+    #>If still running a parallel process, to ensure that readdir is called
+    #>again even if it has now returned nothing.
     if (@files == 0 and $self->{'md5Fork'})
     {
         push @files, undef;
@@ -5169,6 +5249,7 @@ sub DESTROY
 
 ##################################################
 # stellt fest, welches das neue Directory ist, löscht alte
+#>Notes which is the new directory, deleting old
 package adminDirectories;
 use Carp;
 
@@ -5192,6 +5273,7 @@ sub new
     &::setParamsDirect($self, \%params);
 
 # weitere Variablen:
+#>other variables:
 # 'aktDate', 'baseDir', 'aktDir', 'prevDir', 'oldDirs'
 
     my $targetDir = $self->{'targetDir'};
@@ -5209,6 +5291,7 @@ sub new
     $self->{'prevDir'} = $asbd->getFinishedPrev();
 
 # Neues Verzeichnis anlegen
+#>Create a new directory
     $prLog->print('-kind' => 'E',
 		  '-str' => ["cannot create <$aktDir>, exiting"],
 		  '-exit' => 1)
@@ -5240,6 +5323,7 @@ sub new
 
 ########################################
 # sind sortiert: ältestes zuerst
+#>are by: oldest first
 sub getOldDirs
 {
     my $self = shift;
@@ -5305,6 +5389,10 @@ sub getOldInfoFile
 # Stellt nach außen ein Interface analog forkProc zur Verfügung
 # (läuft im Hintergrund als fork/exec)
 # Arbeitet *alle* ab, erst dann wird Ergebnis geliefert
+#>Splits the parameter list (if too long).
+#>Provides an external interface similar to forkProc
+#>(runs in the background as a fork/exec).
+#>Works from *all*, only result is provided.
 package forkMD5;
 
 sub new
@@ -5360,8 +5448,10 @@ sub _startJob
     do
     {
 	my $l = 0;      # akkumulierte Länge der Paramter in Byte
+                        #>cumulative length of the parameter in bytes
 	my $i;
 	my $param = $self->{'param'};    # Pointer auf Parameter Vektor
+                                         #>Pointer to the parameter vector
 
 	for ($i = 0 ; $i < @$param ; $i++)
 	{
@@ -5375,13 +5465,17 @@ sub _startJob
 
 	if ($i == 0)      # der erste paßt überhaupt nicht rein
 	{                 # (ist alleine schon zu lang)
+                          #>the first to fit over not pure
+                          #>(is too long by itself)
 	    my $aktPar = shift @{$self->{'param'}};   # erten "wegwerfen"
+                                                      #>????? "throw away"
 	    $prLog->print('-kind' => 'E',
 			  '-str' => ["parameter to long: cannot exec " .
 				     "md5sum $aktPar"]);
 	    return if @{$self->{'param'}} == 0;
 	}
 	else         # ok, die möglichen aus dem großen Vektor rausholen
+                     #>ok, get out the possible from the large array
 	{
 	    my (@aktPar) = splice(@{$self->{'param'}}, 0, $i);
 	    $main::stat->incr_noForksMD5();
@@ -5393,6 +5487,7 @@ sub _startJob
 					    '-outRandom' =>
 					    $self->{'tmpdir'} . '/fork-md5-');
 	    # Anzahl Bytes berechnen
+            #>Calculate number of bytes
 	    my $sum = 0;
 	    my $p;
 	    foreach $p (@aktPar)
@@ -5417,24 +5512,26 @@ sub processRuns
     my $self = shift;
 
     if ($self->{'fork'})    # Prozess noch nicht ausgewertet
+                            #>Not yet analyzed process
     {
-	if ($self->{'fork'}->processRuns())  # Job läuft noch
+	if ($self->{'fork'}->processRuns())  # Job läuft noch  #>Job runs
 	{
 	    return 1;
 	}
-	else                    # Job ist fertig
+	else                    # Job ist fertig  #>Job is finished
 	{
 	    push @{$self->{'resultSTDERR'}}, @{$self->{'fork'}->getSTDERR()};
 	    push @{$self->{'resultSTDOUT'}}, @{$self->{'fork'}->getSTDOUT()};
 
 	    if (@{$self->{'param'}} > 0)     # noch was übrig
+                                             #>have something left
 	    {
 		$self->_startJob();
 		return 1;
 	    }
 	    else
 	    {
-		return 0;                   # fertig!
+		return 0;                   # fertig!  #>done!
 	    }
 	}
     }
@@ -5547,6 +5644,10 @@ sub new
 #    Überwachung der forks in parForkCopy und parForkCompr
 #    Wenn diese mit neuen Daten gefüttert wurden, Auffüllen
 #    von fifoCopy und fifoCompr über readDirAndCheck
+#>Idea:
+#>   Monitoring the forks in parForkCopy and parForkCompr
+#>   If this were fed with new data, filling fifoCopy and
+#>   fifoCompr via readDirAndCheck
 sub normalOperation
 {
     my $self = shift;
@@ -5619,6 +5720,11 @@ sub normalOperation
                            # daß eine Datei mit der md5-Summe in Bearbeitung
                            # ist, aber keine gleichartigen in der Schlange sind
                            # -> Variable ist Merker + Puffer zugleich
+                           #>Buffer for files that are being compressed or
+                           #>copied. $inProgress{$md5} = [] means that a file
+                           #>with the md5-sum is in progress, but not similar
+                           #>is in the queue
+                           #>Variable is flag + buffer also
 
     my $gnuCopy = 'cp';
     my (@gnuCopyPar) = ('-a');
@@ -5638,6 +5744,8 @@ beginMainLoopNormalOperation:;
 
 	# Warteschlangen füllen solange Platz ist und bis ein Fork
         # beendet ist oder ein neuer gestartet werden kann.
+        #>Queues fill long as there is space and is finished by a fork
+        #>or a new one can be started.
 	while ($filesLeft and
                $fifoCopy->getNoFreeEntries() > 0 and
                $fifoCompr->getNoFreeEntries() > 0 and
@@ -5656,13 +5764,13 @@ beginMainLoopNormalOperation:;
 	    my $n = ($dir, $file, $md5, $type) =
 		$readDirAndCheck->next();
 
-	    if ($n == 0)         # nix mehr zu holen!
+	    if ($n == 0)         # nix mehr zu holen!  #>nothing more to pick!
 	    {
 		$filesLeft = 0;
 		last;
 	    }
 
-	    last if ($type eq 'repeat'); # MD5Sum läuft noch
+	    last if ($type eq 'repeat'); # MD5Sum läuft noch  #>MD5Sum runs
 
 	    if ($file =~ /\n/ and
 		not exists $$suppressWarning{'fileNameWithLineFeed'})
@@ -5674,9 +5782,11 @@ beginMainLoopNormalOperation:;
 	    }
 
             # Ok, wir haben was zu bearbeiten
+            #>Ok, we have something to be processed
             $main::tinyWaitScheduler->reset();
 
 	    # Rechte etc. der Originaldatei lesen
+            #>Read permissions etc. of the original file
 	    my ($dev, $inode, $mode, $uid, $gid, $size, $atime,
 		$mtime, $ctime);
 	    my $_depth = -1;
@@ -5729,7 +5839,7 @@ beginMainLoopNormalOperation:;
 	    }
 
 	    if ($type eq 'd')            # directory anlegen
-	    {
+	    {                            #>Creating a directory
 		if ($lateLinks)
 		{
 		    my $lateDir = $file;
@@ -6075,6 +6185,8 @@ beginMainLoopNormalOperation:;
 
 		    $aktFilename->store('-filename' => $file,# speichert in dbm
 					'-md5sum' => $md5,   # .md5sum-Datei
+                                                             #>stores in dbm
+                                                             #>.md5sum file
 					'-compr' => 'b',
 					'-dev' => $dev,
 					'-inode' => $inode,
@@ -6107,6 +6219,7 @@ beginMainLoopNormalOperation:;
 	    else
 	    {
 		# jetzt in DBM-Files nachsehen und linken
+                #>now look in DBM files and left
 		if ((($inodeBackup, $comprOld, $backupDirIndex,
 		      $backupDir, $linkFile) =
 		     $oldFilename->getFilename($md5)) == 5)
@@ -6148,7 +6261,7 @@ beginMainLoopNormalOperation:;
 		    }
 		}
 		else             # Datei ist noch nicht bekannt
-		{
+		{                #>File is not yet known
 		    $linkFile = undef;
 		}
 	    }
@@ -6167,6 +6280,7 @@ beginMainLoopNormalOperation:;
 	    {
 #print "-3-\n";
                 # Alte Datei komprimiert
+                #>Compress old file
 		if ($comprOld eq 'c')
 		{
                     $newFile .= $postfix;
@@ -6189,9 +6303,12 @@ beginMainLoopNormalOperation:;
 		    $linkFile = undef;
 		    $oldFilename->deleteEntry($md5,    # in Zukunft nicht mehr
 					      $file);  # mit dieser Datei linken
+                                                       #>in the future no longer
+                                                       #>left with this file
                 }
 
                 # In Datei schreiben
+                #>Write to file
                 if ($lateLinks)
 		{
 		    ++$allBackupDirs{$backupDir}
@@ -6206,6 +6323,7 @@ beginMainLoopNormalOperation:;
 		    $main::stat->incr_noLateLinks($uid, $gid);
 
                     # Schreiben der Informationen
+                    #>Write the information
                     $aktFilename->store('-filename' => $file,
                                         '-md5sum' => $md5,
 					'-compr' => $comprOld,
@@ -6220,9 +6338,10 @@ beginMainLoopNormalOperation:;
 					'-gid' => $gid,
 					'-mode' => $mode,
 					'-storeInDBM' => 0  # in dbm sinnlos
+                                                            #>pointless in dbm
                                        );
                 }
-		else  # Oder direkt linken
+		else  # Oder direkt linken  #>Left or right
 		{
 		    if (link $oldFile, $newFile)
 		    {
@@ -6233,6 +6352,7 @@ beginMainLoopNormalOperation:;
 			}
 
 			# Schreiben der Informationen
+                        #>Write the information
 			$aktFilename->store('-filename' => $file,
 					    '-md5sum' => $md5,
 					    '-compr' => $comprOld,
@@ -6247,6 +6367,7 @@ beginMainLoopNormalOperation:;
 					    '-gid' => $gid,
 					    '-mode' => $mode,
 					    '-storeInDBM' => 0  # in dbm sinnlos
+                                                              #>pointless in dbm
 			    );
 			if ($comprOld eq 'u')
 			{
@@ -6265,12 +6386,16 @@ beginMainLoopNormalOperation:;
 				       "<$oldFile> <$newFile>"])
 			    if ($debugMode >= 1);
 			$linkFile = undef;         # => kopieren oder komprimieren
+                                                   #> => copy or compress
 			$oldFilename->deleteEntry($md5,    # in Zukunft nicht mehr
 						  $file);  # mit dieser Datei linken
+                                                       #>in the future no longer
+                                                       #>left with this file
 		    }
 		}
 
                 # Stats nur wenn wirklich gelinkt
+                #>Stats only when really linked
                 if (defined $linkFile)
 		{
                     if ($comprOld eq 'u')
@@ -6299,6 +6424,7 @@ beginMainLoopNormalOperation:;
 	    }
 
             # existiert noch nicht, copy oder compress
+            #>does not exist, copy or compress
 #print "- 4 -\n";
 	    if (not defined $linkFile)
 	    {
@@ -6306,7 +6432,7 @@ beginMainLoopNormalOperation:;
 
 #print "- 5 -\n";
 		if (exists $inProgress{$md5}) # Auf Kompression/Kopie warten
-		{
+		{                             #>Wait for compression/copy
 #print "- 6 -\n";
 		    push @{$inProgress{$md5}}, [$dir, $file, $md5, 'f'];
 		    $prLog->print('-kind' => 'D',
@@ -6316,7 +6442,7 @@ beginMainLoopNormalOperation:;
 		}
 
                 $inProgress{$md5} = [];   # merken, wird kopiert/komprimiert
-
+                                          #>Remember, copied/compressed
 #print "- 7 -\n";
 		no warnings 'newline';
 		if (($comprRule->hasLine() == 1 and
@@ -6324,6 +6450,8 @@ beginMainLoopNormalOperation:;
 					      $uid, $gid, $type) == 1)
 		    or -e "$dir/$file$postfix") # Datei hat nicht .bz2, es
 		{                               # existiert aber Datei mit .bz2
+                                                #>File does not have .bz2 but
+                                                #>there is a file with .bz2
 		    if (-e "$dir/$file$postfix")
 		    {
 #print "- 8 -\n";
@@ -6354,9 +6482,10 @@ beginMainLoopNormalOperation:;
 				    $md5, 'copy']);
                 }
 	    }
-	} # Ende Schleife Warteschlagen füllen
+	} # Ende Schleife Warteschlagen füllen  #>End loop fill queues
 
         # Alte Kopier-Jobs abholen
+        #>Pick up old copy jobs
         foreach my $i ($parForkCopy->checkAll())
         {
             # We did something
@@ -6452,6 +6581,8 @@ beginMainLoopNormalOperation:;
 
             $aktFilename->store('-filename' => $file,  # speichert in dbm
                                 '-md5sum' => $md5,     # .md5sum-Datei
+                                                       #>stores in dbm
+                                                       #>.md5sum file
                                 '-compr' => $compr,
                                 '-dev' => $dev,
                                 '-inode' => $inode,
@@ -6468,6 +6599,8 @@ beginMainLoopNormalOperation:;
             if (exists $inProgress{$md5} and
                 @{$inProgress{$md5}} > 0)  # gepufferte Files mit
             {                              # gleicher md5 Summe bearbeiten
+                                           #>Process buffered files with the
+                                           #>same md5 sum
                 $filesLeft = 1;
                 $readDirAndCheck->pushback($inProgress{$md5}, $prLog,
 		    $debugMode >= 3 ? 1 : 0);
@@ -6476,6 +6609,7 @@ beginMainLoopNormalOperation:;
         }
 
 	# neue Block-md5 Jobs einhägen
+        #>Create new block-md5 jobs
 	while ($parForkBlock->getNoFreeEntries() > 0 and
 	       $fifoBlock->getNoUsedEntries() > 0)
 	{
@@ -6485,6 +6619,7 @@ beginMainLoopNormalOperation:;
 	    my ($devfile, @param) = @{$fifoBlock->get()};
 
 	    # alle md5 Summen berechnen,
+            #>calculate all the md5 sums
 #print "-11- checkBlock, fifoBlock->get: $devfile\n";
 	    my $tmpName = &::uniqFileName("$tmpdir/storeBackup-block.");
 #print "-12-\n";
@@ -6573,6 +6708,7 @@ beginMainLoopNormalOperation:;
 #print "-14-\n";
 
         # neue Kopier-Jobs einhängen
+        #>Create new copy jobs
         while ($parForkCopy->getNoFreeEntries() > 0 and
                $fifoCopy->getNoUsedEntries() > 0)
         {
@@ -6606,7 +6742,7 @@ beginMainLoopNormalOperation:;
 	    }
 
             if ($size <= $main::minCopyWithFork) # direkt kopieren (ohne fork)
-            {
+            {                                    #>Copy directly (without fork)
 #print "-17-\n";
                 $prLog->print('-kind' => 'D',
                               '-str' => ["copy $dir/$file $targetDir/$file"])
@@ -6660,6 +6796,8 @@ beginMainLoopNormalOperation:;
 
                 $aktFilename->store('-filename' => $file,  # speichert in dbm
                                     '-md5sum' => $md5,     # .md5sum-Datei
+                                                           #>stores in dbm
+                                                           #>.md5sum file
                                     '-compr' => $compr,
                                     '-dev' => $dev,
                                     '-inode' => $inode,
@@ -6677,6 +6815,8 @@ beginMainLoopNormalOperation:;
                 if (exists $inProgress{$md5} and
                     @{$inProgress{$md5}} > 0)  # gepufferte Files mit
                 {                              # gleicher md5 Summe bearbeiten
+                                               #>Process buffered files with
+                                               #>the same md5 sum
                     $filesLeft = 1;
                     $readDirAndCheck->pushback($inProgress{$md5}, $prLog,
 			$debugMode >= 3 ? 1 : 0);
@@ -6684,6 +6824,7 @@ beginMainLoopNormalOperation:;
                 delete $inProgress{$md5};
             }
             else                         # mit fork/cp,rsync kopieren
+                                         #>copy with fork/cp,rsync
             {
                 $prLog->print('-kind' => 'D',
                               '-str' =>
@@ -6707,6 +6848,7 @@ beginMainLoopNormalOperation:;
 #print "-18-\n";
 
         # Komprimier Jobs abholen
+        #>Pick up compress jobs
         foreach my $i ($parForkCompr->checkAll())
         {
 #print "-19-\n";
@@ -6826,6 +6968,8 @@ beginMainLoopNormalOperation:;
 #print "- 22 - file = <$file>\n";
             $aktFilename->store('-filename' => $file,  # speichert in dbm
                                 '-md5sum' => $md5,     # .md5sum-Datei
+                                                       #>stores in dbm
+                                                       #>.md5sum file
                                 '-compr' => 'c',
                                 '-dev' => $dev,
                                 '-inode' => $inode,
@@ -6842,6 +6986,8 @@ beginMainLoopNormalOperation:;
             if (exists $inProgress{$md5} and
                 @{$inProgress{$md5}} > 0)  # gepufferte Files mit
             {                              # gleicher md5 Summe bearbeiten
+                                           #>Process buffered files with
+                                           #>the same md5 sum
                 $filesLeft = 1;
                 $readDirAndCheck->pushback($inProgress{$md5}, $prLog,
 		    $debugMode >= 3 ? 1 : 0);
@@ -6851,6 +6997,7 @@ beginMainLoopNormalOperation:;
 #print "-23-\n";
 
         # Block-md5 Jobs abholen
+        #>Pick up block-md5 jobs
 	while (1)
         {
 	    my $i;
@@ -6997,6 +7144,8 @@ beginMainLoopNormalOperation:;
 
 	    $aktFilename->store('-filename' => $file,  # speichert in dbm
 				'-md5sum' => $allMD5,  # .md5sum-Datei
+                                                       #>stores in dbm
+                                                       #>.md5sum file
 				'-compr' => 'b',
 				'-dev' => $dev,
 				'-inode' => $inode,
@@ -7012,6 +7161,7 @@ beginMainLoopNormalOperation:;
 	}
 #print "-25-\n";
         # neue Komprimier-Jobs einhängen
+        #>Create new compress jobs
         while ($parForkCompr->getNoFreeEntries() > 0 and
                $fifoCompr->getNoUsedEntries() > 0)
         {
@@ -7781,7 +7931,7 @@ sub print
     my $backupDuration =
 	$self->{'aktDate'}->deltaInSecs('-secondDate' => $dEnd);
     $backupDuration = 1 if ($backupDuration == 0);   # Minimaler Wert
-
+                                                     #>minimum value
     my $sumTargetAll =
 	$self->{'sumLinkedInternalCopy'} +
 	$self->{'sumLinkedInternalCompr'} +
-- 
1.8.4.rc3

