// Benötigt die rorb Routine
/*s*/ /* code::xor3 */

/*s*/ /* Kommentar*/
/*

      Die Besonderheit an der Routine:
      Wenn der Schlüsselvorrat zu ende ist, wird der Schlüssel Rotiert.
      d.H. der Blockeffekt wird verschleiert.

      Die Rotation wird aus dem Schlüssel selbst ermittelt - also kein
fester Wert.

      Schlüssellänge min 8 Bytes!
*/
/*e*/

// Header
char* code::xor3(char* txt,long txtlength,char* key,long keylength)
{
 long int i = 0; // Long Variable auf Register ablegen und Initialisieren
 long int j = 0; // Die M68K hat 14 Register  - 603 hat 64 und die
 long int k = 0; // G4 insgesammt 128
 int help = 0;            // Hilfvariable :)

    do // Soooolange bis ebbes
    {

        // Diese Schleife Kodiert solange wie der Key nicht zu ende ist und der Text
        // ebenfalls nicht zu ende ist.
        /*Kodieren mit Schlüssel */

        for(j=0;j<keylength & i<txtlength;i++,j++) // i und j hochzählen
        {
            *(txt+i) ^= *(key+j); // XOr *(txt+i++)
        }

        /* Das ganze als while schleife:
           j = 0;
           i = 0;

            while(j<keylength & i<txtlength) // i und j hochzählen
            {
                *(txt+i++) ^= *(key+j++); // XOr *(txt+i++)
            }

        */

        /* Keyrotationslevel ermitteln */

        // Die Zeile hat es in sich :)
            help = ((*(key+help)>>4) & 7)|1;

        // help = der Inhalt vom Key + help um 4 Bits nach rechts geschoben - dann wird
        // mit 7 Verknüpft (um werte über 7 zu vermeiden) und danach wird mindestens der
        // wert 1 Erzeugt.

        // Beispiel:
        // Key: "12345678"
        // help ist (wegen bereits durchgelaufenen Durchlauf) 6

        // *(key+help) = "7" -> 55
        // 55 == %0000000000110111
        // Nu wird um 4 Bit geschoben:
        // %0000000000110111 >> 4 = 0000000000000011
        // Um sicherzustellen das auch wirklich keine Zahl größer 7 herrauskommen kann wird
        // und verknüpft: 00000011
        //    &           00000111
        // macht Aquanta: 3
        // Nur für den Fall das 0 herrauskäme wird das unterste Bit auf 1 gesetzt

        // In dieser Schleife wird der Key selbst Kodiert oder neu erzeugt:
         /* neuen Key errechnen */

        for(j=0 ;j<keylength;j++) // Solange was vom Key da is
        {
            *(key+j) = (unsigned char) rorb(help,*(key+j)); // Key um in Help berechnete Zahl rotieren (siehe rorb)
        }

   }  while(i<txtlength); // Und das ganze bis der gesammte Text Kodiert ist.

   return((char*)txt); // Zeiger auf Kodierten String zurückgeben
}

/*e*/