Asembler - zly kod.

Witam,

NA uczelni dano nam program w asemblerze do porawienia błędów. Część z nich udało mi się poprawić, niestety reszta w obecnej chwili mnie przewyższa. To mój pierwszy tydzień z asemblerem, a już wiem, że nie pałam miłością :P Proszę o pomoc w poprawianiu i jeśli da radę, w zrozumieniu :)

Oto 2 programy:

;=============================================================================;
;                                                                             ;
; Plik           : arch1-7c.asm                                               ;
; Format         : COM                                                        ;
                                               ;
; Uwagi          : Program obliczajacy wzor: (b*b-4*a)/d                      ;
;                                                                             ;
;=============================================================================;

                .MODEL  TINY  ;okreslany jest model programu <64 KB>

				KOD 
             SEG

                ORG    256h ;	program bedzie sie zaczynac od CS:0256H - to jest kolejna cecha programów typu .com
                ASsUME  CS:Kod, DS:Dane, SS:Stos ; Assume jednoznacznie okresla segmenty systemowe

				start:  ;etykieta "poczatek" - moznaby ja z grubsza porównac do adowego begin... 
				
                jmp    Poczatek   ; powoduje przeskok do innej czesci prgramu

a               DB      20
b               =       10
c               DB      7
d               EQU     3
Wynik           DB      ?

Poczatek:
                mov     ax, WORD PTR a
                mul     c   ; mnozenie
                mov     a, bx
                sub     ax, bx   ;odejmij 
                shr     WORD PTR bh, 2
                div     d   ;dzielenie

                mov     al, Wynik

                mov     ax, 4C5h
                int     21h      ;przerwa

Kod:            END

                END   Poczatek





;=============================================================================;
;                                                                             ;
; Plik           : arch1-7e.asm                                               ;
; Format         : EXE                                                        ;
; Cwiczenie      : Kompilacja, konsolidacja i debugowanie programów           ;
;                  asemblerowych                                              ;                                              ;
; Uwagi          : Program dokonujacy konkatenacji dwoch tekstow o znanej     ;
;                  dlugosci                                                   ;
;                                                                             ;
;=============================================================================;

                .MODEL  SMALL  ;okreslany jest model programu <max 64 KB>

Dane            SEG

Napis1          DW      "To jest pierwszy napis",13,10,'$'
DL_NAPIS1       EQU     20
Napis2          DB      "To jest drugi napis",13,10,'$'
DL_NAPIS        EQU     25
Napis3          DB      DL_NAPIS1 - DL_NAPIS2 DUP {?}

Dane            END SEG

Kod             SEG

                ASSuMe	   CS:Kod, DS:Dane, SS:Stos      ; ??? Assume jednoznacznie okresla segmenty systemowe, 'ustawienie' rejestru CS, DS i SS   

Start
                mov     ds, SEG Dane
                mov     cs, ds ; zaladuj watosc ds do cs

                mov     si, OFfSET Napis1 ; okresla odleglosc od poczatku programu
                mov     di, OFfSET Napis2
                mov     cx, DL_NAPIS1

Petla1:
                mov     al, [si]
                mov     [bx], ah
                inc     si
                dec     di
                loop     Petla

                mov     si, SEGMENT Napis1
                mov     cx, DL_NAPIS2

Petla2:
                mov     [di], al
                mov     al, [di]
                dec     si
                loop    Petla1
                inc     di, 1

                mov     ah, 09h
                mov     dx, OFfSET Napis3 ;offset
                int     21h

                mov     ax, 4C020h
                int     21h

Dane            END SEG

Stosik          SEGMENT .STACK   ;stack przechowuje wskaznik wierzcholka stosu

                DB      100h DUP (!)

sik             ENDs SEG  ;koniec segmentu

                END Start

Główne błędy które tu występują:

• a,b,c,d zamiast nazw rejestrów (ax,bx,cx,dx / al,ah / bl,bh...)
• skoki do etykiet z błędną nazwą (skok do pętla kiedy jest tylko petla1 i petla2)

Te błędy są błędami czasu kompilacji (asemblacji) czy runtime? Tzn. nie kompilują (asemblują) Ci się te programy czy po prostu źle działają?

Sam nie sprawdzę bo po archaicznej składni poznaję TASM którego się dawno pozbyłem z dysku - a szkoda mi tracić czasu na analizowanie kodu jeśli trzeba tylko poprawić składnię :>

Napisz na GG to pomoge i wyjasnie gdzie są błędy i oco chodzi.
gg: 7257731

Pierwszy program poprawiony :) CO do drugiego coś jeszcze nie działa.

;=============================================================================;
;                                                                             ;
; Plik           : arch1-7c.asm                                               ;
; Format         : COM                                                        ;                                      ;
; Uwagi          : Program obliczajacy wzor: (b*c-4*a)/d                      ;
;                                                                             ;
;=============================================================================;

;(70-40)/3 = 30/3 =10


 .MODEL  TINY  ;model pamieci, w ktorym kod i dane musza sie zmescic. (max to 64KB) - jedna z cech programu typu .COM
.code ; poczatek segmentu kodu
                ORG    100h ;dyrektywa org 100h, jest informacja dla kompilatora, ze program jest typu .com
				;program bedzie sie zaczynac od CS:0100H 
				; CS - Code Segment.        0101h to liczba w systemie szesnastkowym. Musza zaczynac sie cyfra i konczyc na h. jak hexagonalny.
				
start: 	;poczatek programu ( z :)
               jmp    Poczatek  ;skacze do etykiety poczatek. Bezwarunkwy przeskok.
a              DW      10   ; dwubajtowa liczba calkowita
b              DW      10 
c              DW      7   ; jednobajtowa liczba calkowita
d              DW      3
Wynik          DW      ? 
Poczatek proc near   ; procedura typu near (blisko) 

				;mov CEL, ZRODLO. Sluzy do do kopiowania wartosci miedzy pamieciom a rejestrami, lub tylko miedzy rejestrami.
				mov 	ax, a ;pod rejsetr AX przypisz a. czyli w ax mamy 10.
				mov		bx, 4 ; pod BX przypisz 4
				mul		bx ;mnozenie. pomnóz bx razy ax
				mov		a, ax
				
								
                mov    ax, b ; do rejestru ax przypisz wartosc a;
				mov		bx, c
                mul    bx ;multiply (mnozenie). bx * ax
				
				mov		bx, a
				sub		ax, bx   ;  wykonuje odejmowanie dwuch argumentów i wynik umieszcza w miejscu pierwszego z nich. Od pierwszego drugi.
				mov		bx, d
                div    bx ;divide. Jesli d jest bajtem (tak jak tutaj), to dx jest dzielone przez d. Iloraz zostaje wrzucony do dl, a reszta do dh.
                mov    ax, Wynik  ;wynik do ax
                mov    ax, 4C00h ;zakonczenie programu
                int    21h ;interrup - wywolanie przerwania (33d) 
poczatek endp  ; koniec procedury.
                END    start ;koniec programu
				
				

A to ten, który jeszcze wymaga dopracowania:

Dane            SEGMENT 

Napis1          DB      "To jest pierwszy napis",13,10,'$' 
DL_NAPIS1      EQU    22 
Napis2          DB      "To jest drugi napis",13,10,'$' 
DL_NAPIS2      EQU    19 
Napis3          DB      DL_NAPIS1 DUP (?), DL_NAPIS2 DUP (?),'$' 

Dane            ENDS 


Stosik          SEGMENT STACK  ;polaczenie - stack.  

                DB      100h DUP (?)   ; przechowywanie lacucha znakow na stosie. zmienna przechowuje 256 znakow. (db - samo przechowuje tlyko jeden znak)
                
Stosik            ENDS 



Kod                SEGMENT ;wskazuje segment w pamieci, gdzie przechowywane sa instrukcje
                ASSUME    DS:Dane, SS:Stosik, CS:Kod 
				;segment kodu CS - mówi procesorowi, gdzie znajduja sie dla niego instrukcje.
				;segment danych DS - ten najczesciej pokazuje na miejsce, gdzie trzymamy nasze zmienne.
				;segment stosu SS - dzieki niemu wiemy, w którym segmencie jest nasz stos. 
				;segment dodatkowy ES - czesto uzywany, gdy chcemy cos napisac lub narysowac na ekranie bez pomocy Windows, DOSa czy nawet BIOSu.

Start: 
				; MOVE - przesun, 
                mov    ax, Dane ; dane do AX
                mov    ds, ax    ;bajt z AX do DS   ;czyli do rejastru segmentowego DS(dane) przypsisz Dane.
				; przypisywanie w assemblerze musi odbywac sie po kolei. nie mozna bezposrednio przypisac np. wartosci do segmentu. 
                mov    di, ds 
                mov    si, di 
                mov    si, OFFSET Napis1  ; offset -  adresowanie aegmentów. Odleglosc od poczatku segmentu
                mov    di, OFFSET Napis2 
                mov    cx, DL_NAPIS1 
                mov     BX, offset Napis3 

				
				 ;si, di - Rejestr indeksujacy pamiec oraz wskazujacy obszar z którego przesyla sie dane.
			
Petla1: 
                mov    al, [si] ;  slowo spod adresu DS(segment danych):si do al
                mov    [bx], al  ;slowo z AL pod adresu DS:BX
                inc    si 
                inc    bx 
                loop    Petla1 

                mov    cx, DL_NAPIS2 

Petla2: 
                mov    al,[di] ; slowo spod adresu DS:DI do AL
                mov    [bx], al ; slowo z AL pod adres DS:BX
                inc    di   ;zwieksza o 1. (inkrementuje)
                inc    bx ;zwieksza o 1. (inkrementuje)
                loop    Petla2  ; przeskocz do etykiety Petla 2,  ( zmniejsza wartosc CX o 1. Jesli CX jest wieksze od 0, powoduje przeskok do etykiety)
              
                mov    ah, 09h   ; wyswietlenie napisu
                mov    dx, OFFSET Napis3  ;(Do rejestru danych (DX, 16-bitowy) wstaw offset (adres wzgledem poczatku segmentu) Napis3. 
                int    21h 

                mov    ax, 4C00h 
                int    21h 

Kod             ENDS 

                
                

    
                END Start