Win32ASM. Asembler w Windows

IDZ DO
PRZYK£ADOWY ROZDZIA£

SPIS TRE CI Win32ASM.
Asembler w Windows
KATALOG KSI¥¯EK
Autor: Adam B³aszczyk
KATALOG ONLINE ISBN: 83-7361-022-7
Format: B5, stron: 360
ZAMÓW DRUKOWANY KATALOG

TWÓJ KOSZYK
Przekonanie, ¿e programowanie w asemblerze odesz³o w przesz³o æ wraz z opartymi
DODAJ DO KOSZYKA na interfejsie tekstowym systemami w rodzaju DOS i upowszechnieniem siê
wysokopoziomowych jêzyków programowania takich jak Visual Basic, C++ czy Java,
jest b³êdne. Ca³kiem spora grupa osób nadal u¿ywa asemblera w rodowisku Windows.
CENNIK I INFORMACJE Je li chcesz do nich do³¹czyæ, znalaz³e w³a ciw¹ ksi¹¿kê.
Asembler daje programi cie poczucie ogromnej wolno ci i pe³nego panowania nad
ZAMÓW INFORMACJE sprzêtem. Dziêki tej ksi¹¿ce nauczysz siê programowaæ w tym jêzyku, poznasz równie¿
O NOWO CIACH ca³y zestaw aplikacji, które programowanie to u³atwi¹. W tek cie ksi¹¿ki znajdziesz
wiele przyk³adów kodu ilustruj¹cych najwa¿niejsze omawiane zagadnienia.
ZAMÓW CENNIK Ksi¹¿ka przedstawia:
• Podstawowe informacje zwi¹zane z asemblerem: systemy kodowania,
CZYTELNIA zapis liczb i znaków
• Rejestry i pamiêæ maszyny z punktu widzenia programisty asemblera, adresowanie
FRAGMENTY KSI¥¯EK ONLINE • Instrukcje asemblera i listê rozkazów procesora
• Programowanie z u¿yciem MASM — Makro Asemblera
• U¿ycie programu NMAKE i tworzenie plików Makefile
• Programowanie w Windows: WinAPI
• Biblioteki DLL
• Technologie COM i OLE
• Zasoby programów Windows
Jeszcze jedna metoda tworzenia programów w Windows, która mo¿e zafascynowaæ
osoby lubi¹ce „d³ubanie w kodzie”? Dlaczego nie! Przeczytaj tê ksi¹¿kê, a sam bêdziesz
móg³ oceniæ, czy asembler siê zdewaluowa³.
Programowanie w Windows dla wtajemniczonych.
Wydawnictwo Helion • Poznaj jêzyk asembler dla procesorów Intel i kompatybilnych
ul. Chopina 6 • Naucz siê u¿ywaæ Windows API z poziomu asemblera
44-100 Gliwice • Poznaj narzêdzia u³atwiaj¹ce programowanie
tel. (32)230-98-63
e-mail: helion@helion.pl

Spis treści
Od Autora.......................................................................................... 9
Wstęp ............................................................................................. 11
Rozdział 1. Zanim zaczniemy na poważnie.......................................................... 15
Platform SDK, MSDN ......................................................................................................15
Pakiet Masm32..................................................................................................................16
Narzędziownia...................................................................................................................17
Rozdział 2. Asembler kontra Windows................................................................ 19
Krótko o ró nych rodzinach okienek ................................................................................19
Gdzie się podziały przerwania?.........................................................................................23
Windows API ....................................................................................................................24
Windows z perspektywy asemblera ..................................................................................27
Rozdział 3. Co trzeba wiedzieć? ......................................................................... 31
Systemy liczbowe i nie tylko ............................................................................................31
Informacja i system dwójkowy (binarny) ...................................................................32
Potęgi liczby 2...................................................................................................................33
Jednostki objętości danych................................................................................................37
Kodowanie liczb................................................................................................................37
NKB (naturalny kod binarny) .....................................................................................40
Kod dwójkowo-dziesiętny BCD (Binary Coded Decimal) ........................................41
Reprezentacja liczb ujemnych ....................................................................................42
Reprezentacja stałoprzecinkowa .................................................................................45
Reprezentacja zmiennoprzecinkowa...........................................................................45
Problemy związane z błędami obliczeń......................................................................46
Kodowanie znaków ...........................................................................................................47
ASCII (ISO 646) .........................................................................................................47
ASCII rozszerzone (ASCII Extended, HI-ASCII)......................................................47
Polskie znaki diaktryczne w ró nych systemach kodowania znaków ........................54
ASCIIZ (ASCII Zero) .................................................................................................55
Systemy kodowania MBCS (Multibyte Character Set) i DBCS
(Double Character Set) ............................................................................................55
Unicode .......................................................................................................................56

6 Win32ASM. Asembler w Windows

Rozdział 4. Asembler......................................................................................... 63
Z czego składa się typowy program? ................................................................................63
Program wykonywalny — od środka................................................................................70
Gdzie umieszczać kod i dane? ..........................................................................................73
Zamiana tekstu programu na kod wykonywalny ..............................................................74
Procesory 80x86 — krótkie wprowadzenie ......................................................................77
Pamięć — model płaski.....................................................................................................77
Rejestry..............................................................................................................................80
Rejestry tzw. ogólnego przeznaczenia........................................................................80
Rejestr EIP ..................................................................................................................82
Rejestry segmentowe ..................................................................................................82
Rejestr eflags...............................................................................................................83
Moment uruchomienia programu......................................................................................86
Dostęp do pamięci i sposoby jej adresowania...................................................................87
Adresowanie bezpośrednie .........................................................................................87
Adresowanie pośrednie...............................................................................................88
Adresowanie a wielkość danych .......................................................................................89
Adresowanie a rejestry segmentowe .................................................................................90
Adresowanie łańcuchów ...................................................................................................91
Instrukcje 32- i 16-bitowe .................................................................................................92
Stos ....................................................................................................................................93
Wywoływanie procedur ....................................................................................................94
Przekazywanie parametrów przez rejestry..................................................................95
Przekazywanie parametrów przez stos .......................................................................95
Deklarowanie zmiennych..................................................................................................95
Zmienne, wskaźniki — adresowanie ................................................................................97
Najwa niejsze instrukcje programu ..................................................................................99
Instrukcja mov ............................................................................................................99
Para instrukcji push/pop............................................................................................100
Rozkazy dotyczące operacji na łańcuchach ..............................................................100
Rozkazy arytmetyczne ..............................................................................................101
Etykiety, pętle, skoki.................................................................................................102
Rozkazy związane z procedurami.............................................................................103
Rozkazy logiczne ......................................................................................................105
Rozkazy przesunięć ..................................................................................................106
Lista rozkazów IA-32 — opis skrócony .........................................................................108
Instrukcje transferu danych.......................................................................................108
Instrukcje arytmetyczne ............................................................................................108
Instrukcje porównujące i testujące ustawienie danego bitu......................................108
Instrukcje arytmetyczne (kod BCD) .........................................................................109
Instrukcje logiczne ....................................................................................................109
Instrukcje przesunięć ................................................................................................109
Instrukcje obrotów ....................................................................................................109
Intrukcje operujące na bitach ....................................................................................109
Intrukcje przenoszące kontrolę do innego miejsca w programie..............................109
Intrukcje operujące na łańcuchach............................................................................110
Instrukcje dotyczące rejestru znaczników ................................................................110
Instrukcje dotyczące segmentów ..............................................................................110
Instrukcje ró ne.........................................................................................................110
Rozdział 5. Macro Assembler........................................................................... 131
MASM — Macro Assembler ..........................................................................................131
Jak powstają makra? .................................................................................................133

Spis treści 7

Najwa niejsze informacje o makrach .............................................................................134
Znaki specjalne .........................................................................................................134
Zapis liczb.................................................................................................................134
Przedefiniowane symbole i funkcje ..........................................................................134
Operatory ..................................................................................................................136
Makra związane z procesem asemblacji ...................................................................138
Operatory związane z programowaniem ..................................................................147
Tworzenie własnych makr ........................................................................................155
Plik macro.inc — przykłady u ytecznych makr .......................................................155
Słowa zarezerwowane w języku Macro Assembler........................................................169
Rozdział 6. Pisanie plików makefile — program NMAKE ................................... 175
Zawartość pliku projektowego ........................................................................................175
Bloki komentarzy......................................................................................................176
Bloki opisowe ...........................................................................................................176
Pora na praktykę — budowanie własnych projektów.....................................................178
Uniwersalny makefile (plik makefile.mak).....................................................................179
Rozdział 7. Parametry wywołania programów MASM, LINK, RC i NMAKE .......... 185
Parametry wywołania ML.EXE ......................................................................................185
Parametry wywołania LINK.EXE...................................................................................187
Parametry wywołania RC.EXE.......................................................................................188
Parametry wywołania NMAKE ......................................................................................189
Rozdział 8. Podstawy programowania Windows ................................................ 191
Pojęcie okna ....................................................................................................................192
Komunikaty okna ............................................................................................................193
Szkielet aplikacji dialogowej ..........................................................................................194
Konsola............................................................................................................................195
Podsumowanie ................................................................................................................197
Rozdział 9. Jak korzystać z dokumentacji SDK? ............................................... 209
Notacja węgierska ...........................................................................................................209
Funkcje Win API.............................................................................................................209
Parametry funkcji Win API.............................................................................................213
Funkcje Unicode kontra funkcje ANSI...........................................................................215
Rozdział 10. Win32ASM — graficzny interfejs użytkownika GUI .......................... 223
Rola interfejsu u ytkownika .....................................................................................223
Elementy interfejsu ...................................................................................................225
Zmiany wprowadzone przez Windows XP...............................................................226
Wszystko o oknach ...................................................................................................226
Menu .........................................................................................................................262
Rozdział 11. Zasoby programów Windows .......................................................... 269
Skrypty zasobów w plikach .rc i .res...............................................................................269
Binaria, czyli zasoby w plikach wykonywalnych ...........................................................272
Dostęp do zasobów z poziomu programu.................................................................273
Jeszcze raz o narzędziach..........................................................................................273
Tworzenie plików z zasobami ..................................................................................274
Piszemy własny edytor tekstu...................................................................................275
Inne rodzaje zasobów................................................................................................287
Manifest w Windows XP ..........................................................................................288
Zakładka Wersja — informacje o programie............................................................291


Rozdział 12. WinAPI — najczęściej wykorzystywane funkcje............................... 301
Wersja systemu ...............................................................................................................301
Odczyt parametrów systemu ...........................................................................................301
Dostęp do katalogów systemowych ................................................................................302
Powiadomienia o zmianach (stanu systemu, jego ustawień lub stanu okna itp.)............303
Dostęp do linii poleceń programu ...................................................................................303
Operacje na liczbach i łańcuchach ..................................................................................305
Pliki w systemie Windows ..............................................................................................305
Dostęp do Rejestru ..........................................................................................................306
Liczniki czasowe .............................................................................................................308
Rozdział 13. Zagadnienia wcale niezaawansowane............................................. 309
Biblioteki DLL ................................................................................................................309
Haki w systemie Windows..............................................................................................312
Internet ............................................................................................................................313
Uaktualnianie wersji programu przez internet..........................................................313
Piszemy „konia trojańskiego”, czyli oprogramowanie typu serwer-klient...............317
Rozdział 14. Technologia COM i kontrolki OLE ................................................... 331
Obecność na pasku zadań — interfejs ITaskbarList .......................................................332
Plik skrótu — interfejs IShellLink ..................................................................................338
Najmniejsza przeglądarka świata — interfejs IWebBrowser2 .......................................340
Rozdział 15. Materiały pomocnicze .................................................................... 351
Dokumentacja i podręczniki............................................................................................351
Najwa niejsze strony domowe poświęcone Win32ASM ...............................................351
Opracowania i literatura dotyczące Win32ASM, WinAPI i tematyki pokrewnej ..........352
Asemblery, kompilatory, programy łączące ...................................................................352
Inne..................................................................................................................................353
Wybrane strony z narzędziami........................................................................................353
Rozdział 16. Programy źródłowe......................................................................... 355
Skorowidz...................................................................................... 361

Rozdział 5.
Macro Assembler
Niniejsza część ksią ki poświęcona jest całkowicie przybli eniu podstawowych i najwa -
niejszych z punktu widzenia programisty informacji na temat języka Macro Assembler.

MASM — Macro Assembler
Macro Assembler to język całkowicie typowy i nic dziwnego, e sterują nim pewne,
odgórnie ustalone zasady. Przede wszystkim jest to zwykły asembler, w którym mo na
tworzyć programy w klasyczny sposób — pisząc kolejne instrukcje w osobnych linij-
kach. Prawdziwa siła Macro Assemblera tak naprawdę tkwi jednak w makrach. Czym są
i jak u ywać ich skutecznie w swoich programach opowiemy za chwilę, zastanówmy
się jednak najpierw, co jest największą bolączką programistów piszących w języku
asembler. Odpowiedź na to pytanie znalazła się ju w poprzednim podrozdziale —
chodzi o chaos widoczny w większości programów pisanych w tym języku. Jeśli masz
ju jakieś doświadczenia jako programista pracujący w asemblerze, zapewne znasz
doskonale uczucie towarzyszące przeglądaniu programów źródłowych, szczególnie tych
pochodzących z przeszłości lub pisanych przez innych programistów. Sporo czasu zaj-
muje zwykle zrozumienie sedna sprawy i to tutaj właśnie Macro Assembler ma okazję
pokazać swoje największe zalety, a ju szczególnie swój zbawienny wpływ na przej-
rzystość kodu.

Weźmy na przykład bardzo często stosowaną w asemblerze konstrukcję:
EOR GCZ
LG GCZA
EOR GCZ
LG GCZA

EOR GCZ
LG GCZA


GCZA

LOR FCNGL
GCZA

LOR FCNGL
GCZA

LOR FCNGL

FCNGL

która pozwala na wykonywanie ró nego kodu w zale ności od określonych warunków.
W przypadku jednego rozgałęzienia nie ma problemu, natomiast komplikacje są od razu
widoczne przy większej liczbie warunków. Macro Assembler świetnie rozwiązuje tę
kwestię, pozwalając na uproszczenie tego typu konstrukcji za pomocą bloku +(, któ-
ry dla powy szego przykładu moglibyśmy zastosować w następujący sposób:
+( GCZ

'.5'+( GCZ

'.5'+( GCZ

'0

Od razu rzucają się w oczy trzy rzeczy. Po pierwsze, zapis jest o wiele krótszy; po
drugie, nie musimy korzystać z ucią liwych etykiet; po trzecie — składnia bardzo przy-
pomina zapis języka wy szego poziomu. I tak jest w istocie. Istnieje nawet opinia, i
programowanie w Macro Asemblerze w niedu ym stopniu ró ni się od programowania
w języku C lub podobnym. Chyba ju wiesz, jaką potęgę skupia w sobie ten niepozorny
język?

Tak, tak…

Składnia języka wysokiego poziomu, instrukcje asemblera, bezpośredni dostęp do pa-
mięci, bezpośredni dostęp do funkcji Win API, mo liwość ingerencji w kod programu
na najni szym poziomie i wiele innych czynników, włączając w to jeden drobny, acz
chyba najbardziej lubiany przez wszystkich koderów szczegół — programy wynikowe
są o wiele krótsze ni pisane w językach wysokiego poziomu. Odpowiednio zdefinio-
wany zestaw makr mo e tak e słu yć do wykrywania błędów w programie (ułatwione
śledzenie programu, dzięki informacjom na temat jego wykonywania).

Poznaliśmy ju konstrukcję makra +(. Jeszcze raz popatrzmy, jak wygląda ono w prak-
tyce, biorąc za przykład wykonanie pewnego typowego kodu w zale ności od jakiegoś
warunku. Na szybko wymyślmy sytuację, w której chcemy wyświetlić na ekranie komu-
nikat o błędzie, jeśli wynik zwrócony przez funkcję otwierającą plik jest niepoprawny.

Rozdział 5. ♦ Macro Assembler 133

I tak, zapisany w typowy sposób kod miałby postać:
KPXQMG 1RGP(KNG ; w tym przykładzie parametry nas nie interesują
EOR GCZ ; -1 oznacza tutaj kod błędu
LG $NCF ; jeśli błąd — skok do etykiety Blad
; dalsza część programu, wykonująca się
; / jeśli nie ma błędu
$NCF
; obsługa błędu

Z kolei w języku MASM taka operacja mo e zostać zastąpiona kodem:
KPXQMG 1RGP(KNG ; w tym przykładzie parametry nas nie interesują
+( GCZ ; -1 oznacza tutaj kod błędu
; dalsza część programu, wykonująca się
; / jeśli nie ma błędu
'0+(
; obsługa błędu

Jak powstają makra?
Makra w MASM to bloki tekstu, które mogą być dołączane w dowolnym momencie
kodu. Definicja makra nadaje mu nazwę i opisuje, co dane makro ma robić — z prak-
tycznego punktu widzenia makro ma ogólną postać typu:
0CYC /#%41 CTIWOGPV[
; tutaj umieść treść makra
'0/

Dla przykładu makro, którego celem jest wstawienie do kodu funkcji tzw. epilogu zwra-
cającego daną wartość w rejestrze GCZ, mo e mieć postać:
4'6740 /#%41 EQAYTCECO[
OQX GCZ EQAYTCECO[
TGV
'0/

Wywołanie zdefiniowanego makra wygląda następująco (w przykładzie zwracamy ):
4'6740

Umieszczenie powy szego kodu w programie powoduje, e analizujący kod asembler
po napotkaniu tego wyra enia „rozwinie” je w następujący kod:
OQX GCZ EQAYTCECO[
TGV

a za wartość EQAYTCECO[ zostanie podstawiona wartość , dając finalną wersję kodu:
OQX GCZ
TGV

Powy szy przykład przewija się w wielu programach źródłowych Win32ASM, jakie
mo na znaleźć w internecie.


Najważniejsze informacje o makrach
Pisanie makr oraz wykorzystanie mo liwości języka Macro Assembler są związane
z koniecznością zapoznania się z najwa niejszymi makrami, symbolami oraz opera-
torami u ywanymi do zapisu wyra eń ró nego typu. Zaczniemy od znaków o specjal-
nym znaczeniu.

Znaki specjalne

— oznacza aktualną (tj. w danym momencie procesu asemblacji) wartość
licznika określającego adres bie ącej instrukcji; w praktyce mo na traktować
to jako symboliczny zapis adresu miejsca, w którym symbol ten wystąpił.
!
— symbol u ywany podczas deklaracji danych; jego zastosowanie informuje
asembler, e zmienna zadeklarowana przy u yciu symbolu ! nie ma wartości
początkowej.

— symbol u ywany przy deklaracji etykiet oraz w nazwach przedefiniowanych
symboli (opisanych w następnym podrozdziale).

— symbole u ywane przy deklaracji zmiennych lub stałych tekstowych oraz
podczas łączenia wielu parametrów w jeden ciąg (traktowany jako jeden parametr).
=?
— symbole u ywane przy odwoływaniu się do komórek pamięci.

Zapis liczb
.KEDCF
— reprezentuje .KEDú dziesiętną; z reguły nie trzeba dodawać przyrostka F,
chyba e zostanie zmieniony domyślny system liczbowy (u ywany przez
asembler w trakcie asemblacji).
.KEDCJ
— reprezentuje .KEDú szesnastkową (heksadecymalną); przedrostek dodaje
się w przypadku liczb rozpoczynających się od cyfr szesnastkowych #, $, %, , '
lub (.
.KEDCD
— reprezentuje .KEDú dwójkową (binarną).

Przedefiniowane symbole i funkcje
CVG
— reprezentuje aktualną datę.


6KOG
— reprezentuje aktualny czas.
8GTUKQP
— reprezentuje wersję programu Macro Assembler.
(KNG%WT
— reprezentuje nazwę pliku poddawanego asemblacji.
(KNG0COG
— reprezentuje pełną nazwę pliku poddawanego asemblacji.
EQFG
— dostarcza informacji o segmencie kodu.
FCVC
— dostarcza informacji o segmencie danych.
UVCEM
— dostarcza informacji o segmencie stosu.
%WT5GI
— dostarcza informacji o bie ącym (tzn. tym, w którym aktualnie u yty jest
symbol %WT5GI) segmencie.

Poni szy przykład pokazuje, w jaki sposób mo na wykorzystać opisane symbole do wy-
świetlania informacji diagnostycznych w trakcie kompilowania programu.
archiwum: Win32ASMSrc!Symbole!Symbole.asm
; ===========================================================
; Opis : Demonstracja wykorzystania ró nych
; funkcji wbudowanych w Macro Assembler
; ===========================================================

; instrukcje 586
/1'. (.#656%#.. ; płaski model pamięci
; konwencja STDCALL

EQFG ; sekcja kodu
5VCTV ; początek programu
TGV ; powrót z procedury

'%*1 CVC
CVG CVG
'%*1 %CU
6KOG 6KOG
'%*1 9GTULC
8GTUKQP 8GTUKQP
'%*1 0CYC
(KNG%WT (KNG%WT
'%*1 0CYC RG PC
(KNG0COG (KNG0COG
'%*1 5GIOGPV MQFW
EQFG EQFG
'%*1 5GIOGPV FCP[EJ
FCVC FCVC
'%*1 5GIOGPV UVQUW
UVCEM UVCEM
'%*1 5GIOGPV CMVWCNP[
%WT5GI %WT5GI
'0 5VCTV ; tu zaczyna się program


A oto rezultat przykładowej asemblacji programu.

archiwum: Win32ASMSrc!Symbole!Symbole.txt
+PHQ
EKG MC FQ /#5/ E/CUO
6YQTú RTQLGMV 5[ODQNG
9GTULC 4'.'#5' RNKM ':' DG CUQDÎY
#UUGODNKPI 5[ODQNGCUO
CVC
CVG
%CU
6KOG
9GTULC
8GTUKQP
0CYC
(KNG%WT 5[ODQNGCUO
0CYC RG PC
(KNG0COG 5;/$1.'
5GIOGPV MQFW
EQFG A6':6
5GIOGPV FCP[EJ
FCVC (.#6
5GIOGPV UVQUW
UVCEM (.#6
5GIOGPV CMVWCNP[
%WT5GI A6':6
#D[ MQPV[PWQYCè PCEK PKL FQYQNP[ MNCYKU

Operatory
Operatory matematyczne
9[TC GPKG
9[TC GPKG
— zwraca sumę obu 9[TC G .
9[TC GPKG 9[TC GPKG
— zwraca ró nicę obu 9[TC G .
9[TC GPKG ∗ 9[TC GPKG
— zwraca iloczyn obu 9[TC G .
9[TC GPKG 9[TC GPKG
— zwraca iloraz obu 9[TC G .
9[TC GPKG
— zwraca 9[TC GPKG ze znakiem zmienionym na przeciwny.
9[TC GPKG /1 9[TC GPKG
— zwraca resztę z dzielenia (funkcja /1, funkcja /17.1) 9[TC GPKC przez
9[TC GPKG.

Operatory logiczne
9[TC GPKG #0 9[TC GPKG
— zwraca iloczyn logiczny (funkcja #0) obu 9[TC G .
9[TC GPKG 14 9[TC GPKG
— zwraca sumę logiczną (funkcja 14) obu 9[TC G .


016 9[TC GPKG
— zwraca negację logiczną (funkcja 016) 9[TC GPKC.
9[TC GPKG :14 9[TC GPKG
— zwraca sumę modulo (funkcja :14, inaczej ':%.75+8' 14) obu 9[TC G .

Operatory przesunięć
9[TC GPKG 5*. .KEDC
— zwraca wartość powstałą z przesunięcia w lewo wartości 9[TC GPKC zadaną
.KEDú razy.

9[TC GPKG 5*4 .KEDC
— zwraca wartość powstałą z przesunięcia w prawo wartości 9[TC GPKC zadaną
.KEDú razy.

Operatory porównań
9[TC GPKG '3 9[TC GPKG
— zwraca wartość VTWG (o wartości ), jeśli 9[TC GPKG jest równe 9[TC GPKW;
w przeciwnym przypadku zwraca wartość HCNUG (o wartości ).
9[TC GPKG 0' 9[TC GPKG
— zwraca wartość VTWG (o wartości ), jeśli 9[TC GPKG nie jest równe
9[TC GPKW; w przeciwnym przypadku zwraca wartość HCNUG (o wartości ).
9[TC GPKG )6 9[TC GPKG
— zwraca wartość VTWG (o wartości ), jeśli 9[TC GPKG jest większe od
9[TC GPKC; w przeciwnym przypadku zwraca wartość HCNUG (o wartości ).
9[TC GPKG .6 9[TC GPKG
— zwraca wartość VTWG (o wartości ), jeśli 9[TC GPKG jest mniejsze od
9[TC GPKC; w przeciwnym przypadku zwraca wartość HCNUG (o wartości ).

9[TC GPKG )' 9[TC GPKG
— zwraca wartość VTWG (o wartości ), jeśli 9[TC GPKG jest większe lub równe

9[TC GPKG .' 9[TC GPKG
— zwraca wartość VTWG (o wartości ), jeśli 9[TC GPKG jest mniejsze lub równe

Operatory inne
5GIOGPV9[TC GPKG
— powoduje, e 9[TC GPKG odnosi się do innego 5GIOGPVW ni domyślny; 5GIOGPV
mo e być nazwą rejestru, segmentu, grupy segmentów lub wyra eniem stałym.
9[TC GPKG2QNG ==2QNG??
— zwraca adres będący sumą adresu 9[TC GPKC i adresu 2QNC w strukturze lub
unii; w ten sposób mo na odwoływać się tak e do struktur zagnie d onych np.
9[TC GPKG 2QNG2QNG+PPG; 9[TC GPKG mo e być nazwą rejestru lub zmiennej.


6GMUV
— powoduje, e 6GMUV traktowany jest jako łańcuch tekstowy.
6GMUV
— powoduje, e 6GMUV traktowany jest jako łańcuch tekstowy.
9[TC GPKG
— powoduje, e 9[TC GPKG będące parametrem przekazywanym do makra
będzie traktowane jako łańcuch tekstowy.
9[TC GPKG
— powoduje zastąpienie łańcucha 9[TC GPKG wartością 9[TC GPKC.
#4 9[TC GPKG
— zwraca adres 9[TC GPKC; najczęściej dotyczy zmiennych lokalnych.
1((5'6 9[TC GPKG
— zwraca adres (offset, przesunięcie) 9[TC GPKC; najczęściej dotyczy zmiennych
globalnych.
5+' 9[TC GPKG
— zwraca rozmiar (w bajtach) 9[TC GPKC.

Makra związane z procesem asemblacji
Przyjrzymy się teraz bli ej wszystkim wa niejszym poleceniom, jakie mo na wykorzy-
stać w języku Macro Asembler. Na końcu tego rozdziału przedstawię plik OCMTQKPE,
w którym zawarłem najczęściej u ywane makra, z powodzeniem mo esz ich u yć
w swoich programach, bez konieczności pisania od „zera”.

Makra o charakterze ogólnym

Definicja rodzaju procesora

— pozwala wykorzystywać instrukcje procesora 8086 i koprocesora 8087;
ustawienie domyślne.

— pozwala wykorzystywać instrukcje koprocesora 8087; ustawienie domyślne.

— pozwala wykorzystywać instrukcje procesora 80186 i koprocesora 8087.

nie pozwala na skorzystanie z instrukcji uprzywilejowanych (dotyczy trybu
chronionego).
2
pozwala na u ycie instrukcji uprzywilejowanych (dotyczy trybu chronionego).


— pozwala wykorzystywać instrukcje koprocesora 80287.

— pozwala wykorzystywać instrukcje procesora 80386 i koprocesora 80387; nie
pozwala na skorzystanie z instrukcji uprzywilejowanych (dotyczy trybu chronionego).
2
pozwala na u ycie instrukcji uprzywilejowanych (dotyczy trybu chronionego).

— pozwala wykorzystywać instrukcje koprocesora 80387.

— pozwala wykorzystywać instrukcje procesora 80486 (koprocesor jest
wbudowany w procesor); nie pozwala skorzystanie z instrukcji uprzywilejowanych
(dotyczy trybu chronionego).
2
— pozwala wykorzystywać instrukcje procesora 80486 (koprocesor jest
wbudowany w procesor); pozwala na u ycie instrukcji uprzywilejowanych
(dotyczy trybu chronionego).
01
— nie pozwala wykorzystywać instrukcji koprocesora.

Komentarze
%1//'06 5GRCTCVQT ==6GMUV??
==6GMUV??
==6GMUV?? 5GRCTCVQT
— powoduje, e pierwsza linia (z wyra eniem %1//'06 5GRCTCVQT ==6GMUV??) oraz
wszystkie inne, w których występuje 5GRCTCVQT będą traktowane przez asembler
jako komentarz.
6GMUV
— powoduje, e 6GMUV traktowany będzie jako komentarz.
6GMUV
— powoduje, e 6GMUV traktowany będzie jako komentarz tylko w definicji
makra i nie będzie widoczny na listingu (po rozwinięciu makra).

Listingi
6+6.' 6[VW
— definiuje 6[VW listingu programu.
57$6+6.' 2QFV[VW
lub
57$66. 2QFV[VW
— definiuje 2QFV[VW listingu.


Wyświetlanie informacji (w trakcie asemblacji)
'%*1 -QOWPKMCV
— powoduje wyświetlenie -QOWPKMCVW w trakcie asemblacji.
'%*1 -QOWPKMCV
— powoduje wyświetlenie -QOWPKMCVW w trakcie asemblacji; znak powoduje,
e wszystkie makra tekstowe u yte w -QOWPKMCEKG zostaną „rozwinięte”.
176 -QOWPKMCV
— powoduje wyświetlenie -QOWPKMCVW w trakcie asemblacji.

Dołączanie kodu źródłowego umieszczonego w innym pliku
+0%.7' 0CYC2NKMW
— powoduje, e w miejscu wystąpienia zapisu +0%.7' 0CYC2NKMW zostanie
dołączony tekst zapisany w pliku 0CYC2NKMW; 0CYC2NKMW powinna być objęta parą
nawiasów ostrych … , jeśli w nazwie występuje którykolwiek ze znaków: (lewy
ukośnik), (średnik), (większy ni zero, nawias ostry zamykający), (mniejszy
ni zero, nawias ostry otwierający), (apostrof), (znak cudzysłowia
w standardzie ASCII; dokładniej: znak cala).

Dołączanie zewnętrznej biblioteki w trakcie budowania programu
+0%.7'.+$ 0CYC$KDNKQVGMK
— powoduje, e w trakcie łączenia (budowania) pliku wynikowego program
łączący dołączy bibliotekę zawartą w pliku 0CYC$KDNKQVGMK; 0CYC$KDNKQVGMK
powinna być objęta parą nawiasów ostrych … , jeśli w nazwie występuje
którykolwiek ze znaków: (lewy ukośnik), (średnik), (większy ni zero,
nawias ostry zamykający), (mniejszy ni zero, nawias ostry otwierający),
(apostrof), (znak cudzysłowia w standardzie ASCII; dokładniej: znak cala).

Przerywanie procesu asemblacji

Konstrukcja .ERR
'44 ==-QOWPKMCV??
— powoduje wygenerowanie błędu i przerwanie asemblacji oraz ewentualnie
wyświetlenie -QOWPKMCVW; -QOWPKMCV powinien być objęty parą nawiasów ostrych
… .

Konstrukcja .ERR2
'44 ==-QOWPKMCV??
wyświetlenie -QOWPKMCVW; -QOWPKMCV powinien być objęty parą nawiasów ostrych
… ; w przeciwieństwie do '44, błąd generowany będzie przy ka dym przebiegu
asemblera (opcja 126+105'6+( musi być równa wartości 647').


Konstrukcja .ERRB
'44$ 'NGOGPV == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 'NGOGPV jest pusty; 'NGOGPV i -QOWPKMCV muszą być
objęte parą nawiasów ostrych … .

Konstrukcja .ERRNB
'440$ 'NGOGPV == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 'NGOGPV nie jest pusty; 'NGOGPV i -QOWPKMCV muszą
być objęte parą nawiasów ostrych … .

Konstrukcja .ERRDEF
'44'( 0CYC == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 0CYC była ju wcześniej zdefiniowana jako
zmienna, etykieta lub symbol; -QOWPKMCV powinien być objęty parą nawiasów
ostrych … .

Konstrukcja .ERRNDEF
'440'( 0CYC == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 0CYC nie była wcześniej zdefiniowana jako
zmienna, etykieta lub symbol; -QOWPKMCV powinien być objęty parą nawiasów
ostrych … .

Konstrukcja .ERRDIF
'44+( 'NGOGPV 'NGOGPV == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 'NGOGPV nie jest identyczny z 'NGOGPVGO; 'NGOGPV
i 'NGOGPV muszą być objęte parą nawiasów ostrych … ; małe i wielkie litery
są rozró niane podczas operacji porównania.

Konstrukcja .ERRDIFI
'44+(+ 'NGOGPV 'NGOGPV == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 'NGOGPV nie jest identyczny z 'NGOGPVGO; 'NGOGPV
nie są rozró niane podczas operacji porównania.

Konstrukcja .ERRIDN
'44+0 'NGOGPV 'NGOGPV == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 'NGOGPV jest identyczny z 'NGOGPVGO; 'NGOGPV


są rozró niane podczas operacji porównania.

Konstrukcja .ERRIDNI
'44+0+ 'NGOGPV 'NGOGPV == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 'NGOGPV jest identyczny z 'NGOGPVGO; 'NGOGPV
nie są rozró niane podczas operacji porównania.

Konstrukcja .ERRE
'44' 9[TC GPKG == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 9[TC GPKG zwraca wartość (#.5'; -QOWPKMCV musi być
objęty parą nawiasów ostrych … .

Konstrukcja .ERRNZ
'440 9[TC GPKG == -QOWPKMCV??
wyświetlenie -QOWPKMCVW, jeśli 9[TC GPKG zwraca wartość 647'; -QOWPKMCV musi być
objęty parą nawiasów ostrych … .

Sterowanie przebiegiem asemblacji

Etykiety i skoki
)161 'V[MKGVC
— powoduje, e kolejną przetwarzaną przez asembler linią będzie linia,
w której umieszczono zapis 'V[MKGVC (tj. przed etykietą zawsze występuje
dwukropek); makroinstrukcja )161 mo e być wykorzystywana tylko i wyłącznie
wewnątrz bloków: /#%41, (14, (14%, 4'2'#6, 9*+.'.
'V[MKGVC
— definiuje 'V[MKGVú; do 'V[MKGV[ mo na odwoływać się w innych miejscach
programu za pomocą konstrukcji )161 'V[MKGVC.

Pętle FOR i IRP
(14 2CTCOGVT ==4'3 ^ QO[ NPC?? C EWEJ == C EWEJ?? == ?? == C EWEJ0??
1RGTCELC
'0/
lub równowa ne:
+42 2CTCOGVT ==4'3 ^ QO[ NPC?? C EWEJ == C EWEJ?? == ?? == C EWEJ0??
1RGTCELC
'0/
gdzie:


(14 NWD +42
— określają początek pętli.
2CTCOGVT ==4'3 ^ QO[ NPC??
— oznacza 2CTCOGVT, któremu mo na przypisać wartość QO[ NPæ,
C EWEJ == C EWEJ?? == ?? == C EWEJ0??
— oznaczają kolejne C EWEJ[, na których będzie wykonana zadana 1RGTCELC
w kolejnych obiegach pętli.
'0/
— oznacza koniec bloku.

Pętle FORC i IRPC
(14%
2CTCOGVT C EWEJ 1RGTCELC
'0/
lub równowa ne:
+42%
'0/
gdzie:
(14% NWD +42%
— określają początek pętli.
— oznaczają 2CTCOGVT, któremu będzie przypisana kolejna litera z C EWEJC;
na ka dej z liter będzie wykonana zadana 1RGTCELC.
'0/

Pętla REPEAT i REPT
4'2'#6 .KEDC
-QF
'0/
lub równowa ne:
4'26 .KEDC
-QF
'0/
gdzie:
4'2'#6 .KEDC NWD 4'26 .KEDC
— określają początek pętli oraz .KEDú powtórzeń generowanego -QFW.
-QF
— określa -QF powtarzany zadaną .KEDú razy.
'0/


Pętla WHILE
9*+.' 9[TC GPKG
1RGTCELC
'0/
gdzie:
9*+.' 9[TC GPKG
— określają początek pętli, w której -QF będzie przetwarzany tak długo, jak
długo 9[TC GPKG będzie zwracało wartość prawdziwą.
-QF
— określa -QF asemblowany (w kółko) tak długo, jak długo 9[TC GPKG będzie
zwracało wartość prawdziwą.
'0/

Asemblacja warunkowa
Asemblacja warunkowa pozwala na asemblację wybranych fragmentów kodu w zale -
ności od pewnych parametrów.

Konstrukcja IF
+( 9CTWPGM
9[TC GPKG
=='.5'ZZZZ 9CTWPGM
9[TC GPKG??

=='.5'ZZZZ 9CTWPGM0
9[TC GPKG0??
=='.5'
9[TC GPKG+PPG??
'0+(
gdzie:
+( 9CTWPGM
9[TC GPKG
— oznacza początek konstrukcji — 9[TC GPKG zostanie poddane asemblacji po
wystąpieniu określonego 9CTWPMW.
=='.5'ZZZZ 9CTWPGM
9[TC GPKG??

=='.5'ZZZZ 9CTWPGM0
9[TC GPKG0??
— oznacza kolejne bloki (9[TC GPKG, 9[TC GPKG, , 9[TC GPKG0) wykonywane,
jeśli spełnione są odpowiednio: '.5'ZZZZ 9CTWPGM, '.5'ZZZZ 9CTWPGM, , '.5'ZZZZ
9CTWPGM0, gdzie '.5'ZZZZ mo e przyjmować wartości:

'.5'+( — jeśli… (uproszczona wersja zapisu '.5' +(),
'.5'+($ — jeśli jest puste…,


'.5'+('( — jeśli jest zdefiniowane…,
'.5'+(+( — jeśli następne wyra enie jest inne (małe i wielkie litery są
rozró niane)…,
'.5'+(+(+ — jeśli następne wyra enie jest inne (małe i wielkie litery nie są
rozró niane)…,
'.5'+(' — jeśli jest równe…,
'.5'+(+0 — jeśli następne wyra enie jest identyczne (małe i wielkie litery
są rozró niane)…,
'.5'+(+0+ — jeśli następne wyra enie jest identyczne (małe i wielkie litery
nie są rozró niane)…,
'.5'+(0$ — jeśli jest niepuste…,
'.5'+(0'( — jeśli nie jest zdefiniowane….

=='.5'
9[TC GPKG+PPG??
— określa 9[TC GPKG+PPG wykonywane tylko wtedy, jeśli aden z powy szych
warunków, tj. '.5'ZZZZ 9CTWPGM, '.5'ZZZZ 9CTWPGM, , '.5'ZZZZ 9CTWPGM0,
nie został spełniony.
'0+(
— kończy konstrukcję.

Konstrukcja IFB
+($ 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV jest pusty; składnia jest
identyczna jak w konstrukcji +(.

Konstrukcja IFDEF
+('( 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV był wcześniej zdefiniowany
jako symbol, zmienna lub etykieta; składnia jest identyczna jak w konstrukcji +(.

Konstrukcja IFE
+(' 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV jest równy (wartość HCNUG);
składnia jest identyczna jak w konstrukcji +(.


Konstrukcja IFDIF
+(+( 'NGOGPV 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV i 'NGOGPV są ró ne (małe
i wielkie litery są rozró niane); składnia jest identyczna jak w konstrukcji +(.

Konstrukcja IFDIFI
+(+(+ 'NGOGPV 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV i 'NGOGPV są ró ne (małe
i wielkie litery nie są rozró niane); składnia jest identyczna jak w konstrukcji +(.

Konstrukcja IFIDN
+(+0 'NGOGPV 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV i 'NGOGPV są identyczne (małe
i wielkie litery są rozró niane); składnia jest identyczna jak w konstrukcji +(.

Konstrukcja IFIDNI
+(+0+ 'NGOGPV 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV i 'NGOGPV są identyczne (małe
i wielkie litery nie są rozró niane); składnia jest identyczna jak w konstrukcji +(.

Konstrukcja IFNB
+(0$ 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV jest niepusty; składnia jest
identyczna jak w konstrukcji +(.

Konstrukcja IFNDEF
+(0'( 'NGOGPV
9[TC GPKG

— powoduje asemblację 9[TC GPKC, jeśli 'NGOGPV nie był wcześniej zdefiniowany;
składnia jest identyczna jak w konstrukcji +(.


Konstrukcja IF2
+( 9CTWPGM
9[TC GPKG

— konstrukcja warunkowa +( ma identyczną składnię jak +(; ró nica polega
na tym, e w przypadku konstrukcji +( asembler interpretuje 9CTWPGM tylko raz,
natomiast w przypadku +( — przy ka dym przebiegu (opcja 126+105'6+(
musi być równa wartości 647').

Konstrukcja ELSEIF2
'.5'+( 9CTWPGM
9[TC GPKG

— konstrukcja warunkowa '.5'+( ma identyczną składnię jak '.5'+(;
w przypadku konstrukcji '.5'+( asembler interpretuje 9CTWPGM tylko raz,
natomiast w przypadku +( — przy ka dym przebiegu (opcja 126+105'6+(
musi być równa wartości 647').

Operatory związane z programowaniem
Operatory porównań matematycznych
9[TC GPKG 9[TC GPKG
— znaczenie: czy 9[TC GPKG jest równe 9[TC GPKW?
9[TC GPKG 9[TC GPKG
— znaczenie: czy 9[TC GPKG nie jest równe 9[TC GPKW?
9[TC GPKG 9[TC GPKG
— znaczenie: czy 9[TC GPKG jest większe od 9[TC GPKC?
9[TC GPKG 9[TC GPKG
— znaczenie: czy 9[TC GPKG jest większe lub równe 9[TC GPKW?
9[TC GPKG 9[TC GPKG
— znaczenie: czy 9[TC GPKG jest mniejsze od 9[TC GPKC?
9[TC GPKG 9[TC GPKG
— znaczenie: czy 9[TC GPKG jest mniejsze lub równe 9[TC GPKW?

Operatory porównań logicznych
9[TC GPKG 9[TC GPKG
— znaczenie: czy 9[TC GPKG i 9[TC GPKG są prawdziwe?
9[TC GPKG ^^ 9[TC GPKG
— znaczenie: czy 9[TC GPKG lub 9[TC GPKG są prawdziwe?


9[TC GPKG #0 9[TC GPKG
— znaczenie: czy iloczyn logiczny 9[TC GPKC i 9[TC GPKC jest prawdziwy?
9[TC GPKG
— znaczenie: czy przeciwieństwo 9[TC GPKC jest poprawne?; negacja logiczna.
%#44;!
— znaczenie: czy jest ustawiony znacznik przeniesienia %( w rejestrze
znaczników '(.#)5?
18'4(.19!
— znaczenie: czy jest ustawiony znacznik nadmiaru 1( w rejestrze znaczników
'(.#)5?

2#4+6;!
— znaczenie: czy jest ustawiony znacznik przepełnienia 2( w rejestrze
znaczników '(.#)5?
2#4+6;!
— znaczenie: czy jest ustawiony znacznik znaku 5( w rejestrze znaczników
'(.#)5?

'41!
— znaczenie: czy jest ustawiony znacznik zera ( w rejestrze znaczników
'(.#)5?

Podział programu na sekcje (segmenty)

Deklaracja sekcji (segmentów)
%1' ==0CYC??
— określa początek sekcji (segmentu) kodu; mo e występować wielokrotnie
w treści programu; istnieje mo liwość nadania tej sekcji programu wybranej
0CY[; domyślną nazwą dla modelu (.#6 jest A6':6.

#6#
— określa początek sekcji (segmentu) danych zainicjowanych (z wartościami
początkowymi, z wartościami znanymi w momencie asemblacji); mo e
występować wielokrotnie w treści programu; nazwą tej sekcji dla modelu
(.#6 jest A#6#.
#6#!
— określa początek sekcji (segmentu) danych niezainicjowanych (bez wartości
początkowych, wartości nie są znane w momencie asemblacji); mo e występować
wielokrotnie w treści programu; nazwą tej sekcji dla modelu (.#6 jest A$55.
%1056
— określa początek sekcji (segmentu) danych zainicjowanych (z wartościami
początkowymi, z wartościami znanymi w momencie asemblacji); mo e
występować wielokrotnie w treści programu; sekcja ta posiadać będzie atrybut
„tylko do odczytu”; nazwą tej sekcji dla modelu (.#6 jest %1056.


Sygnalizacja końca modułu, segmentu oraz początku programu
'0
— określa koniec bie ącego modułu.
'0 'V[MKGVC
— określa początek programu jako tego miejsca (tej linii kodu) w programie,
w którym występuje deklaracja 'V[MKGV[; typowo u ywa się zapisu '0 5VCTV.
0CYC '05
— określa koniec segmentu o podanej 0CYKG.

Inne konstrukcje dotyczące sekcji (segmentów)
#.2*#
— ustawia segmenty w kolejności alfabetycznej.
5'3
— ustawia segmenty w kolejności występowania w kodzie; ustawienie
domyślne.
)TWRC )4172 5GIOGPV == 5GIOGPV?? == ?? == 5GIOGPV0??
— dodaje zadane segmenty 5GIOGPV, 5GIOGPV, , 5GIOGPV0 do )TWR[.
#557/' 4GLGUVT0CYC == 4GLGUVT0CYC?? == ?? == 4GLGUVT00CYC??
— pozwala kontrolować błędy wynikające z przypisania 4GLGUVTQO
nieodpowiednich wartości; u ycie #557/' powoduje, e asembler będzie
kontrolował wartości przypisane danym 4GLGUVTQO po czym, w przypadku
wykrycia próby przypisania im niepoprawnej wartości, zgłosi błąd; istnieje
mo liwość całkowitego zabronienia u ycia danych 4GLGUVTÎY przy u yciu
konstrukcji:
#557/' 4GLGUVT'4414 == 4GLGUVT'4414?? == ?? == 4GLGUVT0'4414??
a w celu wyłączenia kontroli wartości przypisywanej 4GLGUVTQO nale y u yć
następującego zapisu:
#557/' 4GLGUVT016*+0) == 4GLGUVT016*+0)?? == ?? == 4GLGUVT0016*+0)??

Typowe konstrukcje

Definicja symboli (stałych) w programie
0CYC 9[TC GPKG
— definicja symbolu 0CYC; definicja mo e być wielokrotnie zmieniana.
0CYC '37 9[TC GPKG
— definicja symbolu 0CYC i przypisanie mu wartości liczbowej 9[TC GPKG;
definicja nie mo e być zmieniana.
0CYC '37 6GMUV
— definicja symbolu 0CYC i przypisanie mu wartości tekstowej 6GMUV; definicja
mo e być zmieniana.


0CYC 6':6'37 ==6GMUV??
— definicja symbolu 0CYC i przypisanie mu wartości 6GMUV; 6GMUV mo e być
łańcuchem tekstowym, stałą poprzedzaną znakiem lub łańcuchem tekstowym
zwracanym przez makro.
0CYC 5+'564 6GMUV
— powoduje przypisanie symbolowi 0CYC wartości będącej długością zadanego
6GMUVW.

Definicja etykiety na poziomie programu
'V[MKGVC
— definiuje 'V[MKGVú; do 'V[MKGV[ mo na odwoływać się w innych miejscach
programu za pomocą instrukcji zmieniających bieg programu (rozkazy skoków,
pętli, wywołania procedur).
'V[MKGVC .#$'. V[R
— definiuje 'V[MKGVú o zadanym 6[RKG; do 'V[MKGV[ mo na odwoływać się
w innych miejscach programu za pomocą instrukcji zmieniających bieg programu
(rozkazy skoków, pętli, wywołania procedur).

Pętle

Pętla .REPEAT .UNTIL
4'2'#6
-QF
706+. 9CTWPGM
— powoduje wykonywanie zadanego -QFW po uruchomieniu programu tak
długo, a zostanie spełniony zadany 9CTWPGM.

Pętla .REPEAT .UNTILCXZ
4'2'#6
-QF
706+. ==9CTWPGM??
— powoduje wykonywanie zadanego -QFW po uruchomieniu programu tak długo,
a wartość rejestru %: przyjmie wartość i ewentualnie zostanie spełniony
dodatkowy 9CTWPGM.

Pętla .WHILE
9*+.' 9CTWPGM
-QF
'09
— powoduje wykonywanie zadanego -QFW po uruchomieniu programu tak długo,
jak długo spełniony jest zadany 9CTWPGM.


Przerywanie pętli za pomocą konstrukcji .BREAK
$4'#- ==+( 9CTWPGM??
— przerywa wykonywanie pętli 9*+.' lub 4'2'#6; mo liwe jest przerwanie
po wystąpieniu określonego 9CTWPMW.

Kontynuacja pętli za pomocą konstrukcji .CONTINUE
%106+07' ==+( 9CTWPGM??
— kontynuuje wykonywanie pętli 9*+.' lub 4'2'#6 od jej początku; mo liwe
jest wykonanie skoku po wystąpieniu określonego 9CTWPMW.

Wyrażenie warunkowe
+( 9CTWPGM
9[TC GPKG
=='.5'+( 9CTWPGM
9[TC GPKG??

=='.5'+( 9CTWPGM0
9[TC GPKG0??
=='.5'
9[TC GPKG??
'0+(
IFKG
+( 9CTWPGM
9[TC GPKG
— oznacza początek konstrukcji — 9[TC GPKG zostanie wykonane po spełnieniu
określonego 9CTWPMW.
=='.5'+( 9CTWPGM
9[TC GPKG??

=='.5'+( 9CTWPGM0
9[TC GPKG0??
— oznacza kolejne bloki (9[TC GPKG, 9[TC GPKG, , 9[TC GPKG0) wykonywane,
jeśli spełnione są odpowiednie 9CTWPGM, 9CTWPGM, , 9CTWPGM0.
=='.5'
9[TC GPKG??
— określa 9[TC GPKG wykonywane tylko wtedy, jeśli aden z powy szych
warunków, tj. 9CTWPGM, 9CTWPGM, , 9CTWPGM0 nie został spełniony.
'0+(
— kończy konstrukcję.

Operacje na łańcuchach
0CYC %#6564 ==6GMUV == 6GMUV?? == ??
— łączy kilka łańcuchów (operacja konkatenacji) w jedną całość; łączone
łańcuchy mogą być stałymi poprzedzanymi znakiem lub łańcuchami
tekstowymi zwracanymi przez makra.


0CYC +0564 ==2Q[ELC ?? 6GMUV 6GMUV
— wyszukuje pierwsze wystąpienie łańcucha tekstowego 6GMUV w łańcuchu
6GMUV; istnieje mo liwość podania 2Q[ELK, od której będzie rozpoczynać się
przeszukiwanie; łańcuchy mogą być stałymi poprzedzanymi znakiem lub
łańcuchami tekstowymi zwracanymi przez makra.

Deklaracja danych

Deklaracja danych w różnych sekcjach programu
(głównie .DATA i .DATA?)
$
— deklaracja danej o rozmiarze 8 bitów — dana typu $;6'.
9
— deklaracja danej o rozmiarze 16 bitów — dana typu 914.

— deklaracja danej o rozmiarze 32 bitów — dana typu 914 (inaczej 17$.'
914).

(
— deklaracja danej o rozmiarze 48 bitów — dana typu (914 (inaczej (#4 914).
3
— deklaracja danej o rozmiarze 64 bitów — dana typu 3914 (inaczej 37#
914).

6
— deklaracja danej o rozmiarze 80 bitów — dana typu 6$;6' (inaczej 6'0 $;6').

Definiowanie struktur
0CYC 5647%
GMNCTCELC2ÎN
0CYC '05
lub
0CYC 5647%6
GMNCTCELC2ÎN
0CYC '05
gdzie:
0CYC 5647% NWD 0CYC 5647%6
— określa początek definicji struktury o podanej 0CYKG.
GMNCTCELC2ÎN
— definiuje części składowe struktury — pola o zadanym typie ($, 9, inne
struktury, itd.).
0CYC '05
— określa koniec struktury o podanej 0CYKG.


Definiowanie unii
0CYC 70+10
GMNCTCELC2ÎN
0CYC '05
gdzie:
0CYC 70+10
— określa początek definicji unii o podanej 0CYKG.
GMNCTCELC2ÎN
— definiuje części składowe unii.
0CYC '05
— określa koniec unii o podanej 0CYKG; w przypadku zagnie d onych bloków
70+10 wystarczy pojedynczy zapis 0CYC '05.

Deklaracja nowych typów
0CYC 6;2''( 6[R
— definiuje nowy typ o podanej 0CYKG, który jest jednoznaczny z 6[RGO.

Deklaracja zmiennych lokalnych w procedurach (funkcjach)
.1%#. OKGPPC$;6'
— deklaracja OKGPPGL 8-bitowej.
.1%#. OKGPPC5$;6'
— deklaracja OKGPPGL 8-bitowej ze znakiem.
.1%#. OKGPPC914
.1%#. OKGPPC914
.1%#. OKGPPC914
.1%#. OKGPPC5914
.1%#. OKGPPC(914
.1%#. OKGPPC3914
.1%#. OKGPPC6$;6'


Inne operacje
#.+)0 ==9CTVQ è??
— powoduje, e adres pierwszej (następnej po wystąpieniu konstrukcji #.+)0)
zadeklarowanej zmiennej będzie wyrównany do wielokrotności 9CTVQ EK.
'8'0
— powoduje, e adres pierwszej (następnej po wystąpieniu konstrukcji '8'0)
zadeklarowanej zmiennej lub u ytej instrukcji będzie wyrównany do adresu
parzystego.

Procedury i funkcje

Deklaracja procedury (funkcji) — PROC i ENDP
0CYC 241% ==KUV?? ==,ú[M?? ==CMTGU?? ==2CT?? == 2CT?? == ?? == 2CT0??
==75'5 .KUVC4GLGUVTÎY?? == 2CTCOGVT ==PCEPKM?? ??
%KC Q
0CYC '02
gdzie:
0CYC 241% ==2CT?? == 2CT?? == ?? == 2CT0?? ==75'5 .KUVC4GLGUVTÎY??
— rozpoczyna definicję procedury o podanej 0CYKG; procedura mo e być
wywoływana z parametrami (2CT, 2CT, , 2CT0); procedura mo e być
wywoływana w programie poleceniem +081-' PCYC lub %#.. PCYC; mo na
określić, które rejestry są niszczone przez procedurę, tak e assembler
automatycznie zadba o zachowanie ich w prologu i przywrócenie w epilogu
procedury (75'5 .KUVC4GLGUVTÎY).
%KC Q
— kod procedury (z reguły kończący się rozkazem 4'6).
0CYC '02
— kończy definicję procedury o zadanej 0CYKG.

Wywołanie procedury (funkcji) — INVOKE
+081-' 0CYC ==2CT?? == 2CT?? == ?? == 2CT0??
— powoduje wywołanie procedury o podanej 0CYKG; istnieje mo liwość
przekazywania parametrów 2CT, 2CT, , 2CT0 do procedury (funkcji); parametry
te zostaną umieszczone na stosie lub w rejestrach w kolejności wynikającej
z przyjętego modelu wywoływania procedur; parametrami mogą być rejestry,
adresy pamięci i wyra enia; asembler jest w stanie sprawdzić, czy liczba
parametrów i ich typ zgadza się z parametrami zadeklarowanymi w ciele
procedury.


Deklaracja prototypu procedury (funkcji) — PROTO
0CYC 24161 == 2CTCOGVT??
— prototyp procedury (funkcji); informuje asembler o istnieniu procedury
(funkcji) o zadanej 0CYKG i atrybutach.

Tworzenie własnych makr
Konstrukcja MACRO
/#%41 0CYC ==2CTCOGVT?? == 2CTCOGVT?? == ?? == 2CTCOGVT0??
-QF/CMTC
'0/
gdzie:
/#%41 0CYC ==2CTCOGVT?? == 2CTCOGVT?? == ?? == 2CTCOGVT0??
— rozpoczyna definicję makra o podanej 0CYKG; makro mo e być wywoływane
z parametrami (2CTCOGVT, 2CTCOGVT, , 2CTCOGVT0); w miejscu wywołania makra
zostanie ono rozwinięte zgodnie z -QFGO/CMTC.
'0/
— kończy definicję makra lub blok 4'2'#6.

Konstrukcja EXITM
':+6/ ==9CTVQ è??
— powoduje zakończenie przetwarzania bie ącego bloku (rozpoczętego
konstrukcją /#%41 lub 4'2'#6); przetwarzanie rozpocznie się od następnej
instrukcji po zakończonym właśnie bloku; istnieje mo liwość zwrócenia
zadanej 9CTVQ EK do wyra enia, które spowodowało wywołanie makra.

Win32ASM. Asembler w Windows

Recommended

Recommended

More Related Content

What's hot

What's hot (19)

Viewers also liked

Viewers also liked (11)

Similar to Win32ASM. Asembler w Windows

Similar to Win32ASM. Asembler w Windows (20)

More from Wydawnictwo Helion

More from Wydawnictwo Helion (20)

Win32ASM. Asembler w Windows