1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:

procedure TfrmMain.btnStartClick(Sender: TObject);

  // Gibt einen 32-Bit Wert zurück, bei dem die angegebenen Bits gesetzt sind.
  function GetMask(FromIndex, Count: Integer): Integer;
  //                  EAX      EDX               EAX
  asm
    push eax            // Register sichern
    mov cl, dl          // Anzahl der Einsen ins Counter-Register
    mov edx, $FFFFFFFF  // EDX mit 1 füllen
    xor eax, eax        // Rückgabewert soll in EAX --> erstmal 0 rein
    shld eax, edx, cl   // Wert in EAX um den Wert im Counter-Register nach
                        // links schieben und mit den Einsen aus EDX füllen
    pop ecx             // Index der ersten Eins in ECX wiederherstellen
    shl eax, cl         // Um den Wert nach links schieben
  end;

  // Rotiert die Bits bei Beachtung der Anzahl der benutzten Bits
  function RotateLeft(Value, RotateBy, Size: Integer): Integer;
  //                   EAX     EDX     ECX               EAX
  asm
    push ebx      // Register sichern
    mov ebx, 1    // 1 in EBX
    shl ebx, cl   // Pos. des nächsthöheren Bits des höchsten Bits steht in CL
    mov ecx, edx  // Schleife initialisieren --> von CL herunterzählen
    @loop:        // Sprungziel für Schleife
    shl eax, 1    // Wert um eins verschieben
    test eax, ebx // Ist das Bit gesetzt?
    jz @nocarry   // Wenn nicht, die 0 im niederwertigsten Bit lassen, ...
    add eax, 1    // ...sonst eine 1 setzen
    xor eax, ebx  // Und die Übertrags-1 weg
    @nocarry:     // Sprungziel für kein Übertrag
    loop @loop    // Schleife ggf. wiederholen
    pop ebx       // Register wiederherstellen
  end;

  // Gibt die Zahl binär mit der angegebenen Anzahl von Stellen aus
  procedure Print(uValue, uDummy, Size: Integer);
  //               EAX     EDX    ECX
  var
    Output: string;
  begin
    Output := StringOfChar('0', Size) ;
    while uValue > 0 do
    begin
      if (uValue and 1) = 1 then
        Output[Size] := '1';
      Dec(Size) ;
      uValue := uValue shr 1;
    end;
    memOutput.Lines.Add(Output); // <-------- Hier kommt der Fehler! <---------------
    Values := Values + #13#10 + AnsiReverseString(Output);
  end;

  // Returns the n for the given parameters
  procedure DoCalculation(a, b, Size: Integer);
  //                     EAX EDX ECX
  var
    Mask: Integer;
  asm
    push edx        // Register sichern
    mov edx, eax    // Die Anzahl ist a
    mov eax, 0      // Startindex ist immer 0

    push ecx
    push edx
    call GetMask    // Die Maske holen, mit deren Hilfe die entsprechenden Bits
                    // gekippt werden --> liegt dann in EAX
    pop edx
    pop ecx

    mov Mask, eax   // In Variable sichern
    mov eax, 0      // Der Startwert für den Wert ist 0
    pop edx         // Um wieviel soll jeweils verschoben werden
    @loopstart:     // Sprungziel für Schleife
    xor eax, Mask   // Bits kippen

    push ecx
    push eax
    call Print      // Ausgeben
    pop eax
    pop ecx

    push ecx
    call RotateLeft // Rotieren, der Wert ist danach wieder in EAX
    pop ecx

    push eax
    push ecx
    call Print      // Ausgeben
    pop ecx
    pop eax

    cmp eax, 0      // Nachsehen, ob EAX schon wieder 0 ist
    jnz @loopstart  // Wenn nicht, weitermachen
  end;

begin
  Values := '';
  DoCalculation(StrToInt(edtA.Text), StrToInt(edtB.Text), StrToInt(edtUmfang.Text));
  memOutput.Text := Trim(Values);
  ShowMessage(IntToStr(memOutput.Lines.Count));
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:

function GetMask(FromIndex, Count: Integer): DWORD;
//  =>  EAX     FromIndex
//  =>  EDX     Cound
//  <=  EAX     Result
asm
    MOV     ECX, EAX    //From index sichern ...
    MOV     EAX, 1      //Let's save an 1 ;-)
    XCHG    EDX, ECX    //We need the shift in CL ...
    SHL     EAX, CL     //Build a power of two ;-)
    DEC     EAX         //Sub one ;-)
    XCHG    EDX, ECX    //Restore our cound *g*
    SHL     EAX, CL     //Make it begin at FromIndex
end;					

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:

function rotateleft(value,size,steps:integer):integer;
asm 
   push esi;
   push ebx;

   rol eax,cl;//rotiert eax um steps, in eax werden im weiteren Bits separiert für die das zulässig war in ebx die Überlaufbits   
   mov ebx,eax;

   xchg ecx,edx;//rol etc gehen nur mit cl deshalb tauschen

   ror ebx,cl;//rotieren um size und zwar rechts herum dies führt dazu dass nun die Überlaufbits in ebx ganz rechts stehen da ja vorher schon um steps nach links gedreht wurde 

   mov esi,$FFFFFFFF;//Maske anfangen
   shl esi,cl;
   not esi;//jetzt sind in einer maske soviele Bits wie des values gesetzt

   and eax,esi;//hier werden aus eax zunächst alles links weggeschnitten   

   xchg ecx,edx;//wieder anderer Zähler nach ecx

   mov esi,$FFFFFFFF;//neue Maske
   shl esi,cl;//soviele Bits von rechts nicht gesetzt wie rotiert werden sollte
   
   and eax,esi;//hier werden die Bits aus eax (der ersten Näherung) geschnitten, die überlaufen und hier also fehlerhaft sind

   not esi;//soviele Bits von rechts gesetzt wie rotiert werden sollte Bsp: 5 steps => ...000011111

   and ebx,esi;//in ebx wird hierduch nur der Überlauf selektiert

   or eax,ebx;//fertig zusammenfügen von rotate und Überlauf

   pop ebx;
   pop esi;
end;