---
title: "BLOK 2: Pętle, tablice i łańcuchy"
date: 2025-11-01T00:00:00Z
lastmod: 2025-12-05T12:30:10+01:00
url: https://klimek.link/student/2025-arch/blok2_skrypt/
author: "Marcin Klimek"
source: https://klimek.link/student/2025-arch/blok2_skrypt/
---

# BLOK 2: Pętle, tablice i łańcuchy

# BLOK 2: Pętle, tablice i łańcuchy

## Informacje organizacyjne

**Termin oddania:** do 02.01.2026  
**Punktacja:** 8 punktów  
**Opóźnienie:** -3 punkty za każdy tydzień  

---

## 1. Środowisko pracy

### Kompilacja w DOSBox-X

```
D:\> cd project
D:\PROJECT> cl program
```

Skrypt `cl` automatycznie wykonuje:
1. `tasm program.asm` - kompilacja do .OBJ
2. `tlink program.obj` - linkowanie do .EXE
3. Wyświetla ewentualne błędy

### Debugowanie - TurboDebugger

```
D:\PROJECT> td program.exe
```

**Podstawowe komendy:**
- `F7` - Step Into (krok do instrukcji)
- `F8` - Step Over (pomiń CALL)
- `F9` - Run to cursor
- `Ctrl+F2` - Reset programu
- `Alt+V` - View menu (rejestry, pamięć, stos)

### Porównanie z Visual Studio

Na zajęciach pokażę jak ten sam kod C wygląda w asemblerze pod Windows (x64).  
To pomoże zrozumieć koncepcje uniwersalne dla każdej architektury.

---

## 2. Instrukcje asemblera - rozszerzenie wiedzy

### 2.1. Pętle w asemblerze

#### Instrukcja LOOP

```asm
mov cx, 10        ; Ustaw licznik na 10
petla:
    ; Kod do powtórzenia
    loop petla    ; CX--, jeśli CX ≠ 0 skocz do 'petla'
```

**Jak działa LOOP:**
1. Dekrementuje CX (CX = CX - 1)
2. Sprawdza czy CX ≠ 0
3. Jeśli tak - skacze do etykiety
4. Jeśli CX = 0 - kontynuuje dalej

**UWAGA:** LOOP **zawsze** dekrementuje CX, nawet jeśli CX=0!  
Wtedy CX staje się FFFFh (65535) → pętla wykona się 65535 razy!

#### Alternatywa: pętle z porównaniem

```asm
mov cx, 0         ; Licznik od 0
petla:
    ; Kod
    inc cx
    cmp cx, 10
    jl petla      ; Jump if Less (cx < 10)
```

**Porównanie:**

| Metoda | Zalety | Wady |
|--------|--------|------|
| LOOP | Krótki kod, klasyczny | Tylko malejący licznik, ryzyko przy CX=0 |
| CMP+JMP | Dowolny kierunek, elastyczny | Dłuższy kod |

### 2.2. Operacje na stringach (łańcuchach)

Procesor ma specjalne instrukcje do pracy ze stringami. Używają rejestrów **SI** (source index) i **DI** (destination index).

#### Flaga kierunku (DF)

```asm
cld    ; Clear Direction Flag - SI/DI rosną (w górę pamięci)
std    ; Set Direction Flag - SI/DI maleją (w dół pamięci)
```

**ZAWSZE** ustawiaj `cld` na początku operacji stringowych!

#### LODSB/LODSW - Load String

```asm
; LODSB - Load String Byte
lodsb    ; AL = [DS:SI], następnie SI++

; LODSW - Load String Word
lodsw    ; AX = [DS:SI], następnie SI+=2
```

#### STOSB/STOSW - Store String

```asm
; STOSB - Store String Byte
stosb    ; [ES:DI] = AL, następnie DI++

; STOSW - Store String Word
stosw    ; [ES:DI] = AX, następnie DI+=2
```

#### MOVSB/MOVSW - Move String

```asm
; MOVSB - Move String Byte
movsb    ; [ES:DI] = [DS:SI], SI++, DI++

; MOVSW - Move String Word
movsw    ; [ES:DI] = [DS:SI], SI+=2, DI+=2
```

#### CMPSB/CMPSW - Compare String

```asm
; CMPSB - Compare String Byte
cmpsb    ; Porównuje [DS:SI] z [ES:DI], SI++, DI++, ustawia flagi

; CMPSW - Compare String Word
cmpsw    ; Porównuje słowa, SI+=2, DI+=2
```

#### SCASB/SCASW - Scan String

```asm
; SCASB - Scan String Byte
scasb    ; Porównuje AL z [ES:DI], DI++, ustawia flagi

; SCASW - Scan String Word
scasw    ; Porównuje AX z [ES:DI], DI+=2
```

#### Prefiksy powtarzania

```asm
rep movsb      ; Powtarzaj MOVSB dopóki CX ≠ 0 (CX razy)
repz cmpsb     ; Powtarzaj dopóki ZF=1 i CX≠0 (dopóki równe)
repnz scasb    ; Powtarzaj dopóki ZF=0 i CX≠0 (dopóki różne)
```

### 2.3. Adresowanie tablic

#### Podstawowe tryby

```asm
mov al, [bx]       ; AL = bajt pod adresem DS:BX
mov ax, [si]       ; AX = słowo pod adresem DS:SI
mov bl, [di]       ; BL = bajt pod adresem DS:DI (lub ES:DI dla stringów)
```

#### Displacement (przesunięcie)

```asm
mov al, [bx+5]     ; AL = bajt pod adresem DS:BX+5
mov ax, [si+10]    ; AX = słowo pod adresem DS:SI+10
```

#### Indeksowanie złożone

```asm
mov al, [bx+si]    ; AL = bajt pod adresem DS:BX+SI
mov ax, [bp+di]    ; AX = słowo pod adresem SS:BP+DI
```

#### Przesunięcie + indeks

```asm
mov al, [bx+si+5]  ; AL = bajt pod adresem DS:BX+SI+5
```

### 2.4. Różnica: bajt vs słowo w tablicach

**KRYTYCZNE DO ZROZUMIENIA:**

```asm
.data
    tablica_b db 10, 20, 30, 40, 50    ; Tablica bajtów
    tablica_w dw 10, 20, 30, 40, 50    ; Tablica słów (dwa bajty)

.code
    ; Dostęp do tablicy bajtów
    mov si, 0
    mov al, tablica_b[si]    ; AL = 10
    inc si                   ; SI = 1
    mov al, tablica_b[si]    ; AL = 20
    
    ; Dostęp do tablicy słów
    mov si, 0
    mov ax, tablica_w[si]    ; AX = 10
    add si, 2                ; SI = 2 (słowo = 2 bajty!)
    mov ax, tablica_w[si]    ; AX = 20
```

**Częsty błąd:** Inkrementacja `inc si` dla tablicy słów - to da dostęp do środka słowa!

```asm
; BŁĄD:
mov si, 0
mov ax, tablica_w[si]    ; AX = 10 (00 0A w pamięci little-endian)
inc si                   ; SI = 1 - wskazuje ŚRODEK słowa!
mov ax, tablica_w[si]    ; AX = nieprawidłowa wartość
```

---

## 3. Przykłady: C vs Asembler

### Przykład 1: Pętla for - zliczanie

**Kod C:**
```c
int count = 0;
for (int i = 0; i < 10; i++) {
    count++;
}
printf("Count: %d\n", count);
```

**Asembler x86-16 (TASM):**
```asm
.model small
.stack 256
.data
    wynik dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    mov cx, 10        ; i = 10 (liczymy w dół)
    mov ax, 0         ; count = 0
    
petla:
    inc ax            ; count++
    loop petla        ; i--, if i != 0 goto petla
    
    mov wynik, ax     ; Zapisz wynik
    
    ; Zakończenie
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Visual Studio (x64 - do demonstracji):**
```asm
; Visual Studio - Disassembly view
    mov dword ptr [count], 0
    mov dword ptr [i], 0
    jmp short check_loop
loop_body:
    mov eax, dword ptr [count]
    inc eax
    mov dword ptr [count], eax
    mov eax, dword ptr [i]
    inc eax
    mov dword ptr [i], eax
check_loop:
    cmp dword ptr [i], 10
    jl short loop_body
```

**Analiza różnic:**
- DOS: Używamy `CX` i instrukcji `LOOP` - procesor to rozumie natywnie
- x64: Kompilator używa jawnych porównań `CMP` i skoków `JL`
- DOS: 16-bit rejestry (AX, CX)
- x64: 32/64-bit rejestry (EAX, RAX)

### Przykład 2: Tablica - suma elementów

**Kod C:**
```c
int tablica[5] = {10, 20, 30, 40, 50};
int suma = 0;

for (int i = 0; i < 5; i++) {
    suma += tablica[i];
}

printf("Suma: %d\n", suma);
```

**Asembler (TASM) - wersja 1 z LOOP:**
```asm
.model small
.stack 256
.data
    tablica dw 10, 20, 30, 40, 50    ; 5 słów
    suma dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    mov cx, 5              ; Licznik elementów
    mov si, 0              ; Indeks (w bajtach)
    mov ax, 0              ; Akumulator sumy
    
petla:
    add ax, tablica[si]    ; suma += tablica[i]
    add si, 2              ; Następny element (słowo = 2 bajty)
    loop petla
    
    mov suma, ax           ; Zapisz wynik
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Asembler (TASM) - wersja 2 z LODSW:**
```asm
.model small
.stack 256
.data
    tablica dw 10, 20, 30, 40, 50
    suma dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    cld                    ; Kierunek w górę
    lea si, tablica        ; SI wskazuje na tablicę
    mov cx, 5              ; 5 elementów
    mov bx, 0              ; Akumulator sumy
    
petla:
    lodsw                  ; AX = [DS:SI], SI += 2
    add bx, ax             ; suma += AX
    loop petla
    
    mov suma, bx
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Analiza:**
- **Wersja 1:** Jawne indeksowanie `tablica[si]`
- **Wersja 2:** Użycie instrukcji stringowej `LODSW` - procesor automatycznie przesuwa SI
- Oba podejścia są poprawne, `LODSW` jest bardziej "idiomatic" dla x86

### Przykład 3: String - długość łańcucha

**Kod C:**
```c
char tekst[] = "Hello";
int dlugosc = 0;

while (tekst[dlugosc] != '\0') {
    dlugosc++;
}

printf("Długość: %d\n", dlugosc);
```

**Asembler (TASM) - wersja 1 ręczna:**
```asm
.model small
.stack 256
.data
    tekst db 'Hello', 0    ; String zakończony zerem
    dlugosc dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    
    mov si, 0              ; Indeks
    
petla:
    mov al, tekst[si]      ; Pobierz bajt
    cmp al, 0              ; Czy koniec?
    je koniec              ; Jeśli tak - zakończ
    inc si                 ; dlugosc++
    jmp petla
    
koniec:
    mov dlugosc, si        ; Zapisz długość
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Asembler (TASM) - wersja 2 z SCASB:**
```asm
.model small
.stack 256
.data
    tekst db 'Hello', 0
    dlugosc dw 0

.code
main proc
    mov ax, @data
    mov ds, ax
    mov es, ax             ; ES = DS (SCASB używa ES:DI)
    
    cld                    ; Kierunek w górę
    lea di, tekst          ; DI wskazuje na tekst
    mov al, 0              ; Szukamy zera
    mov cx, 0FFFFh         ; Maksymalna długość
    
    repnz scasb            ; Szukaj AL w [ES:DI], aż znajdziesz (ZF=1)
    
    ; CX teraz zawiera: FFFFh - długość - 1
    ; Dlatego długość = FFFFh - CX
    neg cx                 ; CX = -CX
    dec cx                 ; CX = -(FFFFh - długość - 1) - 1 = długość
    
    mov dlugosc, cx
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Analiza:**
- **Wersja 1:** Prosta, zrozumiała, jawna logika
- **Wersja 2:** Używa specjalizowanej instrukcji `SCASB` z prefiksem `REPNZ`
  - `REPNZ` = Repeat while Not Zero (dopóki nie znajdzie)
  - Po zakończeniu CX zawiera liczbę pozostałych iteracji
  - Matematyka: długość = max_cx - pozostałe_cx - 1

### Przykład 4: Debugowanie w TurboDebugger

**Program do zademonstrowania:**
```asm
.model small
.stack 256
.data
    tablica db 1, 2, 3, 4, 5

.code
main proc
    mov ax, @data
    mov ds, ax
    
    mov cx, 5
    mov si, 0
    mov bl, 0
    
petla:
    mov al, tablica[si]    ; Breakpoint tutaj (F9)
    add bl, al
    inc si
    loop petla
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Co pokazać studentom w TD:**
1. View → Registers - obserwacja CX, SI, BL w czasie rzeczywistym
2. View → Dump - zawartość pamięci, tablica w formacie heksadecymalnym
3. View → Stack - jak wygląda stos programu
4. F7 (Step) - wykonanie instrukcji krok po kroku
5. Śledzenie jak:
   - `CX` maleje z każdym `LOOP`
   - `SI` rośnie co iterację
   - `BL` akumuluje sumę
   - Flagi ZF, CF się zmieniają

---

## 4. Zadania do wykonania

### Forma oddawania

Każde zadanie oddajemy jako:
1. **Kod źródłowy** (.asm)
2. **Skompilowany program** (.exe)
3. **Sprawozdanie** (PDF lub MD) zawierające:
   - Opis znalezionego błędu
   - Wyjaśnienie DLACZEGO jest to błąd (z perspektywy architektury)
   - Poprawiony kod
   - Wynik działania programu

### Zadanie 6: Zliczanie znaków (kod z błędem)

**Treść zadania:**
Poniższy program ma wczytywać znaki z klawiatury aż do naciśnięcia Enter (kod 0Dh),  
a następnie wyświetlić liczbę wprowadzonych znaków (bez liczenia samego Enter).

**Kod z błędem:**
```asm
.model small
.stack 256
.data
    komunikat db 'Wprowadz tekst: $'
    wynik db 0Dh, 0Ah, 'Liczba znakow: $'

.code
main proc
    mov ax, @data
    mov ds, ax
    
    ; Wyświetl komunikat
    lea dx, komunikat
    mov ah, 09h
    int 21h
    
    mov cx, 0              ; Licznik znaków
    
wczytuj:
    mov ah, 01h            ; Funkcja 01h - czytaj znak z echo
    int 21h
    
    inc cx                 ; Zwiększ licznik
    
    cmp al, 0Ah            ; Czy to Enter?
    jne wczytuj            ; Jeśli nie - czytaj dalej
    
    ; Wyświetl wynik
    lea dx, wynik
    mov ah, 09h
    int 21h
    
    ; Wyświetl liczbę (zakładamy < 10)
    mov ax, cx
    add al, '0'
    mov dl, al
    mov ah, 02h
    int 21h
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Twoje zadanie:**
1. Uruchom program i przetestuj
2. Znajdź błąd (jest ich kilka - znajdź główny)
3. Wyjaśnij:
   - Co program robi źle?
   - Jaki kod zwraca klawisz Enter w DOS? (sprawdź w skrypcie lub dokumentacji)
   - Dlaczego licznik jest niepoprawny?
4. Popraw kod i dołącz wynik działania

**Podpowiedź:** Sprawdź co zwraca INT 21h/AH=01h po naciśnięciu Enter w DOS.

---

### Zadanie 7: Odwracanie ciągu znaków (kod z błędem)

**Treść zadania:**
Program ma wczytać ciąg znaków (max 20 znaków) zakończony Enterem,  
a następnie wyświetlić go w odwrotnej kolejności.

**Kod z błędem:**
```asm
.model small
.stack 256
.data
    bufor db 21 dup(0)        ; Bufor na 20 znaków + Enter
    komunikat db 'Wpisz tekst (max 20 znakow): $'
    wynik db 0Dh, 0Ah, 'Odwrocony tekst: $'

.code
main proc
    mov ax, @data
    mov ds, ax
    
    ; Wyświetl komunikat
    lea dx, komunikat
    mov ah, 09h
    int 21h
    
    ; Wczytaj znaki do bufora
    mov si, 0
    
wczytuj:
    mov ah, 01h
    int 21h
    
    cmp al, 0Dh               ; Enter?
    je zakoncz_wczytywanie
    
    mov bufor[si], al
    inc si
    cmp si, 20                ; Max 20 znaków
    jl wczytuj
    
zakoncz_wczytywanie:
    ; SI zawiera długość
    ; Teraz wyświetl w odwrotnej kolejności
    
    lea dx, wynik
    mov ah, 09h
    int 21h
    
    ; Wyświetl od końca
    mov cx, si                ; CX = długość
    
wyswietl:
    dec si
    mov dl, bufor[si]
    mov ah, 02h
    int 21h
    loop wyswietl
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Twoje zadanie:**
1. Uruchom program i przetestuj z różnymi długościami tekstu
2. Znajdź błąd związany z krótkim tekstem (np. 1 znak)
3. Wyjaśnij:
   - Co się dzieje gdy wpiszesz tylko 1 znak?
   - Dlaczego program wyświetla nieprawidłowe znaki?
   - Jaki jest stan SI po `dec si` gdy SI=0?
4. Popraw kod

**Podpowiedź:** Co się stanie gdy wykonasz `dec si` a SI już jest zerem?  
Jak to wpływa na `bufor[si]` w kontekście 16-bitowego adresowania?

---

### Zadanie 8: Tablica liczb - suma (kod z błędem)

**Treść zadania:**
Program ma obliczyć sumę elementów tablicy 5 liczb i wyświetlić wynik.

**Kod z błędem:**
```asm
.model small
.stack 256
.data
    tablica dw 100, 200, 50, 75, 25     ; Suma = 450
    suma dw 0
    komunikat db 'Suma elementow tablicy: $'

.code
main proc
    mov ax, @data
    mov ds, ax
    
    ; Oblicz sumę
    mov cx, 5              ; 5 elementów
    mov si, 0              ; Indeks
    
petla:
    mov ax, tablica[si]
    add suma, ax
    inc si                 ; Następny element
    loop petla
    
    ; Wyświetl komunikat
    lea dx, komunikat
    mov ah, 09h
    int 21h
    
    ; Wyświetl sumę (zakładamy < 1000, 3 cyfry)
    mov ax, suma
    
    ; Setki
    mov bl, 100
    div bl                 ; AL = setki, AH = reszta
    add al, '0'
    mov dl, al
    mov ah, 02h
    int 21h
    
    ; Dziesiątki i jedności - dalszy kod...
    ; (uproszczone dla zadania)
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Twoje zadanie:**
1. Uruchom program
2. Program prawdopodobnie się zawiesi lub da błędny wynik - dlaczego?
3. Znajdź błąd w pętli
4. Wyjaśnij:
   - Jak duży jest element typu `dw` (word)?
   - O ile bajtów powinniśmy przesuwać SI dla tablicy słów?
   - Co się stanie gdy robimy `inc si` dla tablicy `dw`?
   - Gdzie w pamięci SI będzie wskazywać po pierwszym `inc si`?
5. Popraw kod

**Podpowiedź:** Tablica `dw` = tablica **słów**. Słowo = 2 bajty.  
Jak to wpływa na przesuwanie indeksu?

---

### Zadanie 9: Znajdź maksimum (kod z błędem)

**Treść zadania:**
Program ma znaleźć wartość maksymalną w tablicy 10 liczb bez znaku (unsigned).

**Kod z błędem:**
```asm
.model small
.stack 256
.data
    ; Tablica liczb bez znaku (unsigned byte)
    tablica db 45, 120, 33, 255, 67, 200, 15, 89, 178, 50
    maksimum db 0
    komunikat db 'Maksimum: $'

.code
main proc
    mov ax, @data
    mov ds, ax
    
    ; Znajdź maksimum
    mov cx, 10             ; 10 elementów
    mov si, 0
    mov al, 0              ; Aktualne maksimum
    
petla:
    mov bl, tablica[si]
    cmp bl, al
    jl nie_wieksze         ; Jump if Less (bl < al)
    mov al, bl             ; Nowe maksimum
    
nie_wieksze:
    inc si
    loop petla
    
    mov maksimum, al
    
    ; Wyświetl komunikat
    lea dx, komunikat
    mov ah, 09h
    int 21h
    
    ; Wyświetl wartość (uproszczone)
    mov dl, al
    add dl, '0'
    mov ah, 02h
    int 21h
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Twoje zadanie:**
1. Uruchom program i sprawdź wynik
2. Program nie znajduje prawidłowego maksimum - dlaczego?
3. Znajdź błąd koncepcyjny
4. Wyjaśnij:
   - Z jaką wartością inicjalizujemy AL?
   - Co się stanie jeśli wszystkie liczby w tablicy są większe od 0?
   - Jaka liczba jest największa w tablicy?
   - Dlaczego algorytm nie znajduje tej liczby?
5. Wyjaśnij różnicę między instrukcjami:
   - `JL` (Jump if Less)
   - `JG` (Jump if Greater)
   - Która jest poprawna dla naszego przypadku?
6. Popraw kod

**Podpowiedź:** Pomyśl jak powinno wyglądać prawidłowe **zainicjalizowanie** maksimum.  
Czy inicjalizacja na 0 ma sens dla algorytmu znajdowania maksimum?

---

### Zadanie 10: Sortowanie bąbelkowe (kod z błędem)

**Treść zadania:**
Program ma posortować rosnąco tablicę 8 liczb algorytmem sortowania bąbelkowego  
i wyświetlić posortowaną tablicę.

**Kod z błędem:**
```asm
.model small
.stack 256
.data
    tablica db 64, 34, 25, 12, 22, 11, 90, 88
    n dw 8
    komunikat db 'Posortowana tablica: $'

.code
main proc
    mov ax, @data
    mov ds, ax
    
    ; Sortowanie bąbelkowe
    ; Zewnętrzna pętla (i = 0 to n-1)
    mov cx, n
    dec cx                 ; CX = n-1 (liczba przejść)
    
petla_zewnetrzna:
    push cx                ; Zapisz licznik zewnętrzny
    
    ; Wewnętrzna pętla (j = 0 to n-i-1)
    mov bx, 0              ; BX = indeks j
    
petla_wewnetrzna:
    ; Porównaj tablica[j] z tablica[j+1]
    mov al, tablica[bx]
    mov dl, tablica[bx+1]
    
    cmp al, dl
    jle nie_zamieniaj      ; Jump if Less or Equal (al <= dl)
    
    ; Zamień miejscami
    mov tablica[bx], dl
    mov tablica[bx+1], al
    
nie_zamieniaj:
    inc bx
    cmp bx, cx             ; j < n-1-i?
    jl petla_wewnetrzna
    
    pop cx                 ; Przywróć licznik zewnętrzny
    loop petla_zewnetrzna
    
    ; Wyświetl posortowaną tablicę
    lea dx, komunikat
    mov ah, 09h
    int 21h
    
    mov cx, 8
    mov si, 0
    
wyswietl:
    mov dl, tablica[si]
    add dl, '0'            ; Konwersja na ASCII (dla cyfr < 10)
    mov ah, 02h
    int 21h
    
    mov dl, ' '            ; Spacja
    mov ah, 02h
    int 21h
    
    inc si
    loop wyswietl
    
    mov ax, 4C00h
    int 21h
main endp
end main
```

**Twoje zadanie:**
1. Uruchom program i sprawdź wynik
2. Program nie sortuje poprawnie - dlaczego?
3. Znajdź błąd w warunku pętli wewnętrznej
4. Wyjaśnij:
   - Algorytm bąbelkowy wymaga: każdy element porównać z następnym
   - Ile razy powinna wykonać się pętla wewnętrzna w pierwszym przejściu?
   - Jaka wartość jest w CX podczas pętli wewnętrznej?
   - Czy porównanie `cmp bx, cx` jest poprawne?
   - Co powinno być prawidłowym warunkiem dla pętli wewnętrznej?
5. Dodatkowe pytanie: Dlaczego używamy `jle` zamiast `jge`?
6. Popraw kod i załącz prawidłowo posortowaną tablicę

**Podpowiedź:** Pętla wewnętrzna powinna wykonać się `n-1` razy w pierwszym przejściu,  
`n-2` razy w drugim itd. Czy aktualny kod to realizuje?  
Przeanalizuj wartość CX w kontekście obu pętli.

---

## 5. Wskazówki ogólne

### Dobre praktyki

1. **Zawsze inicjalizuj rejestry**
   ```asm
   mov cx, 0    ; Jawna inicjalizacja
   ```

2. **Sprawdzaj rozmiary danych**
   ```asm
   db = 1 bajt, inc si o 1
   dw = 2 bajty, inc si o 2 (lub add si, 2)
   ```

3. **Używaj CLD przed operacjami stringowymi**
   ```asm
   cld          ; Zawsze przed LODSB, STOSB itd.
   ```

4. **Testuj skrajne przypadki**
   - Pusta tablica
   - Jeden element
   - Maksymalne wartości

### Częste błędy

1. **Off-by-one errors**
   - Pętla wykonuje się o 1 za dużo/mało
   - Nieprawidłowa inicjalizacja licznika

2. **Błędna inkrementacja dla słów**
   ```asm
   ; ŹLE dla tablicy DW:
   inc si
   
   ; DOBRZE:
   add si, 2
   ```

3. **Niepoprawna inicjalizacja**
   ```asm
   ; ŹLE dla znajdowania max:
   mov al, 0
   
   ; DOBRZE:
   mov al, tablica[0]  ; Pierwszy element
   ```

4. **Zapomnienie o znaku liczb**
   - `JL` vs `JB` (signed vs unsigned)
   - `JG` vs `JA` (signed vs unsigned)

### Przydatne instrukcje do zadań

| Instrukcja | Opis | Przykład |
|------------|------|----------|
| `LOOP etykieta` | CX--, if CX≠0 jump | Pętle liczące |
| `INC reg/mem` | Zwiększ o 1 | `inc si` |
| `DEC reg/mem` | Zmniejsz o 1 | `dec cx` |
| `CMP op1, op2` | Porównaj (op1-op2) | Ustawia flagi |
| `JE/JZ` | Jump if Equal/Zero | Po CMP |
| `JNE/JNZ` | Jump if Not Equal | Po CMP |
| `JL/JNGE` | Jump if Less (signed) | `a < b` |
| `JG/JNLE` | Jump if Greater (signed) | `a > b` |
| `JB/JNAE` | Jump if Below (unsigned) | `a < b` |
| `JA/JNBE` | Jump if Above (unsigned) | `a > b` |

---

## 6. Kryteria oceny

**Każde zadanie oceniane jest według:**

| Kryterium | Punkty |
|-----------|--------|
| Program działa poprawnie | 40% |
| Znaleziono i opisano błąd | 30% |
| Wyjaśnienie architektury | 20% |
| Jakość kodu i dokumentacji | 10% |

**Uwaga:** Nawet jeśli nie uda Ci się w pełni naprawić programu, możesz otrzymać punkty za:
- Prawidłową identyfikację problemu
- Merytoryczne wyjaśnienie
- Próbę naprawy (nawet częściową)

**Liczy się proces uczenia się i zrozumienie architektury!**

---

## 7. Podsumowanie: Co powinniśmy wynieść z BLOKU 2

Po tym bloku powinieneś rozumieć:

1. **Jak procesor wykonuje pętle**
   - Rola rejestru CX
   - Jak działa instrukcja LOOP
   - Alternatywy: CMP + warunkowe skoki

2. **Jak procesor adresuje tablice**
   - Różnica między bajtami (DB) a słowami (DW)
   - Tryby adresowania: [SI], [BX+SI], [BX+5]
   - Dlaczego słowa wymagają inkrementacji o 2

3. **Specjalizowane instrukcje stringowe**
   - LODSB/W, STOSB/W, MOVSB/W
   - Rola flag kierunku (CLD/STD)
   - Prefiksy REP, REPZ, REPNZ

4. **Mapowanie algorytmów C na asembler**
   - Jak pętla `for` staje się `LOOP`
   - Jak indeksowanie tablicy `arr[i]` staje się `[SI]`
   - Różnice między wysokopoziomowymi a niskopoziomowymi konstrukcjami

5. **Debugowanie na poziomie architektury**
   - Śledzenie rejestrów w czasie rzeczywistym
   - Obserwacja pamięci i stosu
   - Identyfikacja błędów związanych z architekturą (nie tylko logicznych)

**To nie jest kurs programowania - to kurs zrozumienia jak komputer działa od środka!**

---

Powodzenia! 

Marcin Klimek  
Architektura i Organizacja Systemów Komputerowych  
WSB Nowy Sącz, 2025/2026

Source: https://klimek.link/student/2025-arch/blok2_skrypt/
