HLA Zsebkönyv

Országok listájaHungaryDebreceni EgyetemInformatikai KarProgramtervező informatikusSzámítógép ArchitektúrákEgyéb SegítségHLA Zsebkönyv

HLA zsebkönyv

HLA zsebkönyv
1 Áttekintés
Ez a zsebkönyv azoknak készült, akik már ismer sek az x86 assembly nyelv programozásával és a lehet leggyorsabban szeretnének elkezdeni dolgozni a HLA fordítóprogrammal. A HLA olyan egyetemi hallgatók számára készült, akik már rendelkeznek el zetes magas szint nyelv (C/C++, Pascal, Java, stb.) programozási tapasztalatokkal, de még nem dolgoztak assembly nyelvvel. A HLA-val kapcsolatos dokumentáció kétféle forrásból származik: a HLA kézikönyvéb l és az "Az assembly nyelv programozás m vészete/32 bites kiadás" könyvb l. "Az assembly m vészete" könyv szövege diákoknak és kezd knek szól; nem tételez fel el ismereteket és a HLA használatával tanítja az assembly nyelv programozást. Sajnos, ez a szöveg nem igazán azoknak a programozóknak szól, akik már tudnak assembly nyelven programozni. A HLA kézikönyvei nagyszer ek akkor, ha a nyelv valamely sajátságára vagyunk kíváncsiak. Teljes részletességgel leírják a HLA nyelvet, de a HLA nyelv meglehet sen terjedelmes, így a HLA nyelvvel el ször találkozó assembly programozónak hatalmas mennyiség anyagot kell elsajátítania ahhoz, hogy egyáltalán el tudjon kezdeni dolgozni a HLA-val. A legtöbben meg sem próbálják. Ennek a zsebkönyvnek az a célja, hogy a haladó x86 assembly programozónak minél kisebb terjedelemben bemutassa a HLA egy egészen kis részét. Nem is akarja megtanítani a HLA egyetlen különlegességét sem; feltételezi, hogy az olvasó már ismeri a MASM, TASM, NASM, Gas, stb. assemblerek valamelyikét, és csak azt akarja megtanulni, hogyan lehet a HLA-val az említett assemblereknél megszokott módon assembly kódot írni. A HLA tanulásának célja az, hogy annak fejlett tulajdonságait is használni tudjuk. Természetesen, miel tt futni tudnánk, meg kell tanulnunk járni; ez a kézi könyv járni tanít. Amint az olvasó ,,hagyományos assembly" értelemben megismerkedett a HLA-val, át kell térnie a HLA kézikönyveire, hogy a nyelv haladóknak szánt tulajdonságait is megismerje.

2

A HLA üzembe helyezése
Ez a zsebkönyv feltételezi, hogy a HLA a számítógünkön már már üzemkész és helyesen m ködik. Az üzembe állítás részletes leírását a HLA Kézikönyv tartalmazza.

3

A HLA futtatása
A HLA olyan, parancssorból futtatható segédprogram, amelyet a Win32 parancssorából lehet futtatni. Ez a dokumentum feltételezi, hogy az olvasó már jól ismeri az alapvet parancsok kiadásának módját és az olyan parancsokat, mint "DIR" vagy "RENAME". A HLA-t parancssorból egy ilyen paranccsal lehet futtatni:
hla esetleges_parancssori_paraméterek fájlnevek_listája

A fájlnevek listája egy vagy több egyértelm fájlnévb l áll, amely fájlnevek kiterjesztése HLA, ASM, vagy OBJ lehet. A HLA el ször a HLAPARSE programot futtatja le valamennyi HLA kiterjesztés fájlon (egy ugyanolyan nev , de .ASM vagy .INC kiterjesztés fájlt hozva létre). Ezután a HLA a MASM programot futtatja az összes ASM kiterjesztés fájlon (beleértve a HLAPARSE által létrehozott fájlokat is). Végül, a HLA a linker (kapcsolatszerkeszt ) programot futtatja az OBJ fájlok (beleértve a MASM által létrehozott .OBJ fájlokat is) összekapcsolására. A végeredmény, feltéve, hogy nem fordult el hiba, egy .EXE kiterjesztés végrehajtható fájl. A HLA a következ parancssori paramétereket értelmezi:

Randall Hyde dokumentumának magyarítása

Page 1

-@ -aXXXXX -c -dXXXXX -e name -lXXXXX -m -masm -o:omf -o:win32 -s -sm -st -sym -tasm -test -v -w -?

Ne készíts linker válasz fájlt. Add át az assemblernek XXXXX-et parancssori paraméterként. Csak .OBJ fájlokat készíts. Definiáld a XXXXX szibólumot a fordítás idejére 'igaz' értékkel. A végrehajtható fájl neve. Add át a linkernek XXXXX-et parancssori paraméterként. Készíts memóriatérkép fájlt a linkelés során. Használd az MASM-et a kimen fájl készítésére. A MASM használata során OMF outputot készíts COFF helyett. Készíts Win32 COFF fájlokat. Csak .ASM fájlokat készíts. MASM-stílusú .ASM fájlokat készíts (alapértelmezett). TASM-stílusú .ASM fájlokat készíts. Készíts szimbólum táblázatot a fordítás után. Használd a TASM32.EXE assemblert. A diagnosztikai üzeneteket a stdout-ra küldd a stderr helyett (Ez a parancs a HLA tesztelésére/hibakeresésére való). Részletes fordítási üzenetek. Windows alkalmazásként fordíts (alapértelmezett a konzol). Írd ki ezt a súgó üzenetet

A parancssori paraméterek leírását a HLA Kézikönyvben találja meg. A legtöbb esetben nem lesz szüksége ilyen paraméterek megadására, ha egy tipikus HLA programot fordít. Felhasználóként legtöbbször a "-c" és "-s" paramétereket fogja használni (és ez a dokumentum feltételezi, hogy a felhasználó tudja, hogy azok mire valók).

Page 2

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv

4

A HLA nyelv elemei
Ezzel a szakasszal megkezdjük a HLA forrásnyelv tárgyalását. A HLA forrásnyelvi fájljai csak 7 bites ASCII jeleket tartalmazhatnak. Ezek Windows szövegfájlok, amelyek kocsi vissza/soremelés párossal végz dnek. Nem nyomtatódó jelek a bet köz, a tabulátor és az új sor. Általában a HLA nem fogad el vezérl karaktereket és hibaüzenetet adhat, ha ilyen jelenik meg a forrás fájlban.

4.1

Megjegyzések
A HLA a "//" jelölést használja egysoros megjegyzések bevezetésére. Határozatlan hosszúságú megjegyzés bevezetésre pedig a "/*", lezárására a "*/" jeleket. A C/C++, Java, és Delphi nyelvek használói megszokottnak érezhetik e jelölés használatát.

4.2

Különleges jelek
A következ jelek a HLA lexikális elemei és a HLA számára különleges jelentéssel bírnak: * / + - ( ) [ ] { } < > : ; , . = ? & | ^ ! @ && ## || #( <= )# >= #{ <> }# != == := .. << >>

Ez a dokumentum nem magyarázza meg valamennyi jel jelentését, csak annyit, amennyi egyszer HLA programok írásához szükséges. További részletekért lásd a HLA Kézikönyvet.

4.3

Kulcsszavak
A HLA nagyszámú kulcsszót használ (nagyobbrészt gépi utasításokat). Terjedelmi okokból a listát itt nem mutatjuk be; a teljes és id szer listát a HLA Kézikönyv tartalmazza. Megjegyezzük, hogy a HLA nem engedi meg ezen kulcsszavak használatát azonosítóként, ezért legalább egyszer nézze át ezt a listát, hogy valamennyire megismerje, milyen azonosítókat használhat assembly nyelv programjaiban. A HLA nem különbözteti meg a kulcsszavakban a kis- és nagybet ket. Azaz, a HLA a ,,MOV" és ,,Mov" kulcsszót (továbbá a kis és nagybet k bármilyen el fordulását) a ,,mov" kulcsszóként értelmezi.

4.4

Küls szimbólumok és assembler kulcsszavak
A HLA a fordítás során egy assembly nyelv fájlt készít és meghívja a MASM, TASM és Gas assemblerek valamelyikét a fordítás befejezésére. A HLA a programban talált közönséges azonosítókat azonosítóként adja át az assembly programnak. A HLA azonban nem fordítja le az EXTERNAL szimbólumokat, csak meg rzi azokat a készített assembly nyelv programban. Emiatt vigyáznunk kell arra, hogy ezek a küls nevek ne ütközzenek a használni kívánt assembler kulcsszavaival, mert olyan esetben az assembler hibaüzenetet fog adni a HLA által készített fájl feldolgozásakor. Az assembler kulcsszavak listáját a HLA által készített file továbbfordítására használni kívánt assembler (MASM, TASM, vagy Gas) leírásában találjuk meg.

Randall Hyde dokumentumának magyarítása

Page 3

HLA Documentation

4.5

A HLA azonosítói
A HLA azonosítóinak alfabetikus jellel vagy aláhúzás jellel kell kezd dni. Az els jel után, az azonosító alfanumerikus jeleket és aláhúzást tartalmazhat. A HLA-ban nincs technikai határa az azonosító hosszának, de nem érdemes 32 jelnél hosszabb azonosítókat használni, mivel az azonosítókat feldolgozó assembler és linker esetleg nem tud kezelni ilyen szimbólumokat. A HLA nem követeli meg, hogy az azonosítókban kis- vagy nagybet ket használjon. Ez azt jelenti, hogy a HLA megkülönbözteti a kis és nagybet ket, tehát az azonosítókat mindig azonos módon kell leírnia. Nem megengedett olyan azonosítók használata, amelyek között kizárólag az a különbség, hogy a szóban kis- vagy nagybet k szerepelnek.

4.6

Küls azonosítók
A HLA lehet vé teszi, hogy a programozó küls azonosító szövegeket adjon meg. A küls azonosítókra nem vonatkoznak a HLA azonosítók korlátozásai. A HLA megengedi bármilyen string használatát küls azonosítóként. A programozó felel sége, hogy csak a HLA közbüls ASM fájlját feldolgozó assembler által megengedett jeleket használjon. Megjegyezzük, hogy ez a tulajdonság lehet vé teszi olyan jelek használatát, amelyek nem engedélyezettek a HLA-ban, de használhatók a küls kódban (pl. a Win32 API használja a '@' jelet azonosítókban). További részletek az @EXTERNAL kulcsszó tárgyalásánál.

4.7

Adattípusok a HLA-ban

4.7.1

A HLA primitív (egyszer ) adattípusai
A HLA a következ egyszer adattípusok használatát teszi lehet vé:
Egybájtos típusok: byte, boolean, enum, uns8, int8, és char. Kétbájtos típusok: word, uns16, int16. Négybájtos típusok: dword, uns32, int32, real32, string, pointer. Nyolcbájtos típusok: uns64, int64, qword, thunk, és real64. Tízbájtos típusok: tbyte, és real80. Tizenhatbájtos típusok: uns128, int128, lword, és cset

A fenti típusok részletes tárgyalását lásd a HLA kézikönyvben. Ez a dokumentum a következ típusokat használja:
byte, word, dword, string, real32, qword, real64, és real80

Ezek azok az adattípusok, amelyeket egy tipikus assembler használni képes. A BYTE változók és objektumok a -128..+255 tartományba es numerikus értékeket, ASCII karakter konstansokat, valamint a true (1) és false (0) logikai értékeket képesek tárolni. Bár a HLA általában végez egy minimális típusvizsgálatot, minden olyan értéket lehet benne tárolni, ami nyolc bitben elfér. A WORD változók és objektumok a -32768..+65535 tartományba es numerikus értékeket tárolhatnak. A HLA általában nem engedi meg más értékeknek WORD objektumban való tárolását. A DWORD változók és objektumok a -2147483647..+4294967295 tartományba es numerikus értékeket, vagy egy objektum címét (a ,,&" cím-operátorral) tárolhatják. A STRING változók szintén DWORD objektumok. A STRING objektumok egy nulla vagy több jelb l álló álló, nullával végz d ASCII jelsorozat címét tartalmazza. A string mutatót közvetlenül megel z négy bájtban a string aktuális hossza található. Az aktuális hossz el tti négy bájt pedig a string maximális lehetséges hosszát tartalmazza. Megjegyezzük, hogy a HLA stringek ,,csak olvasható" értelemben kompatibilisek a Windows és C/C++ által használt ASCIIZ stringekkel (a csak olvasható itt azt jelenti, hogy a HLA át tud adni a Windows vagy C/C++ függvénynek egy stringet, de a függvénynek nem szabad azt módosítania). Version: 5/7/02 Written by Randall Hyde

Page 4

HLA zsebkönyv A QWORD, UNS64, és INT64 objektumok nyolc bájtot foglalnak el a memóriában. A HLA az 1.37 változattól kezdve támogatja 64-bites el jel nélküli, el jeles és hexadecimális numerikus állandók használatát. A TBYTE objektumok a memóriában 10 bájtot (80 bitet) foglalnak el, de a HLA nem támogatja a 80-bites egész vagy BCD konstansok használatát a programokban. Az LWORD, UNS128 és INT128 értékek szintén használhatók és 128 bites hexadecimális, el jel nélküli vagy el jeles konstansok használatát támogatják. A HLA REAL32, REAL64, and REAL80 adattípusai az IEEE három különböz formátumát támogatják. lebeg pontos

4.8

Összetett adattípusok
A fenti egyszer adattípusokon felül a HLA támogatja tömbök, rekordok (struktúrák), uniók, osztályok és a fenti típusokra mutató pointerek használatát (szöveg objektumokat kivéve).

4.8.1

,,Tömb" adattípus
A HLA lehet vé teszi hogy tömb adattípust úgy hozzunk létre, hogy a tömb típusjelzése után a tömb elemeinek számát is megadjuk. Tekintsük a következ HLA típus deklarációt amely az intArray tömböt dword objektumokból álló adattömbként definiálja:
type intArray : dword[ 16 ];

A "[ 16 ]" komponens azt mondja meg a HLA-nak, hogy ebben az adattípusban 16 darab 4 bájt hosszú dupla szó van. A HLA nulla alapú indexelést használ, azaz az els elem mindig a nulladik. Az utolsó elem indexe, ebben a példában, 15 (az összes, 0..15 index elemek száma 16). A HLA többdimenziós tömbök használatát is támogatja. Többdimenziós tömböt úgy adhatunk meg, hogy szögletes zárójelek között megadjuk az indexek listáját, pl.
type intArray4x4 : dword[ 4, 4 ]; type intArray2x2x4 : dword[ 2,2,4 ];

4.8.2

Rekord adattípus1
A HLA rekordok lehet vé teszik, hogy a programozó különböz típusú mez ket tartalmazó adattípusokat hozzon létre. A következ HLA statikus változó deklaráció egy négy mez t tartalmazó egyszer rekordot definiál:
static Planet: record x: y: z: density: endrecord;

dword; dword; dword; real64;

Egy Planet típusú objektum futás közben 20 bájtnyi tárterületet foglal el. Egy rekord mez inek típusa bármely HLA adattípus lehet, beleértve más összetett adattípusokat is. A rekord mez inek elérésére a pont jelölést használjuk, pl.
m o v ( Planet.x, eax );

1.

C/C++ programozóknak: Egy HLA rekord egy C struktúrára hasonlít. Számítógép-nyelv tervez k nyelvén a rekordot gyakran ,,Descartes szorzatnak" is hívják.

Randall Hyde dokumentumának magyarítása

Page 5

4.9

Konstansok (literálok)
A HLA konstansok számos típusát támogatja. A következ szakaszok ezeket a típusokat írják le.

4.9.1

Numerikus konstansok
A HLA különböz típusú numerikus konstansok használatát teszi lehet vé. Decimális konstans: A decimális egész konstansok els és utolsó jegye csak decimális számjegy (0..9) lehet. A konstans belsejében decimális számjegyek és aláhúzás jelek egyaránt el fordulhatnak. Az aláhúzás jelek célja a nagy decimális értékek jobb ábrázolhatósága (azaz aláhúzást használhatunk a nagy számértékek tagolására a vessz helyett). Például: 1_234_265. Hexadecimális konstans: A hexadecimális konstansok dollár jellel ("$") kezd dnek, hexadecimális jellel (0..9, A..F, vagy a..f) folytatódnak és azzal is fejez dnek be. A konstansok belsejében hexadecimális jelek vagy aláhúzás jelek állhatnak. A hexadecimális állandókat könnyebb olvasni, ha a számjegyeket (a legkisebb helyiérték számtól kezdve) négyesével csoportokra osztjuk, a csoportokat egymástól aláhúzás jellel elválasztva. Például: $1A_2F34_5438. Bináris konstans: A bináris konstansok százalékjellel ("%") kezd dnek és legalább egy bináris számjeggyel (0/1) folytatódnak, továbbá bináris számjeggyel végz dnek. A bels pozíciók bináris számjegyeket vagy aláhúzás jeleket tartalmazhatnak. A bináris állandókat könnyebb olvasni, ha a számjegyeket (a legkisebb helyiérték számtól kezdve) négyesével csoportokra osztjuk, a csoportokat egymástól aláhúzás jellel elválasztva. Például: %10_1111_1010. Valós (Lebeg pontos) konstans: A lebeg pontos (valós) állandók mindig decimális számjeggyel (és sohasem csak tizedesponttal) kezd dnek. Az egy vagy több decimális számjegy után tizedespont következhet és nulla vagy több decimális számjegy (a törtrész). A törtrész után "e" vagy "E", el jel ("+" or "-") és egy vagy több decimális számjegy következhet (a kitev rész). Aláhúzás jel el fordulhat a lebeg pontos szám szomszédos számjegyei között, ezek a tagolásra használt vessz jeleket helyettesítik. Logikai konstans: A logikai konstansoknak true and false el re definiált értéke lehet. Megjegyezzük, hogy a programozó átdefiniálhatja ezeket az értékeket, de azt rossz programozási stílusnak tekintjük.. Karakter konstans: A karakter konstansok általában aposztrófok közé zárt egyetlen (grafikus) karakterb l állnak. Az aposztrófot négy idéz jellel ábrázolhatjuk, pl. `'''. A karakter állandók megadásának egy másik módja a "#" jelet követ en egy numerikus (decimális, hexadecimális vagy bináris) konstans megadása. Pl.: #13, #$D, #%1 101. Szöveg konstans: A szöveg konstansok idéz jelek közé zárt (grafikus) jelek sorozatából állnak. Egy ilyen szövegben aposztrófot úgy ábrázolhatunk, ha aposztróf párokat írunk be a szövegbe, pl. "He said ""This"" to me." Ha két szöveg konstans egymás mellett van a forrásfájlban (azaz csak nem nyomtatódó jelek választják el egymástól) akkor a HLA a két szöveget összef zi és a parsernek egyetlen szövegként adja tovább. Hasonlóképpen, ha egy karakter konstans van egy szöveg mellett, a HLA a karaktert a szöveghez csatolja és egyetlen szöveggé f zi össze azokat. Ez például akkor hasznos, ha vezérl karaktereket kell egy stringben ábrázolni, pl.
"This is the first line" #$d #$a "This is the second line" #$d #$a

A HLA a fentieket egy olyan szövegként kezeli, ahol mindkét sor után új sor jel (CR/LF) áll.

Pointer konstans:

Randall Hyde dokumentumának magyarítása

Page 6

A HLA csak er sen korlátozott formában engedi meg pointer konstansok használatát. Ha a statikus objektum neve (pl. statikus változó neve, csak olvasható változó neve, nem-inicializált változó, szegmens változó, függvény, módszer vagy iterátor) elé ampersand (,,&") jelet teszünk, futási id alatt kiszámítja annak a változónak a cím offset értékét. Pointer változók nem használhatók konstans kifejezésekben. Pointer konstansokat csak olyan kifejezésekben használhatunk, amelyekkel statikus vagy csak olvasható változókat inicializálunk vagy amely kifejezéseket 80x86 utasításokkal kapcsolatban használunk.
Strukturált konstans:

A HLA támogatja bizonyos strukturált konstansok használatát, beleértve szöveges konstans, tömb konstans és rekord konstans használatát. Részletek a HLA Kézikönyvben.

4.10

Konstans kifejezések a HLA-ban
A HLA a fordítási id ben kiszámítandó kifejezések feldolgozására gazdag lehet ségeket kínál. A HLA a következ operátorokat támogatja (csökken precedencia szerint rendezve): ! (egyoperandusú nem) , - (egyoperandusú negálás) *, div, mod, /, <<, >> +, =, = =, <>, !=, <=, >=, <, > &, |, &, in

! expr

A kifejezésnek bool vagy számértéknek kell lennie. Bool változók esetén, not ("!") a standard logikai nem m veletet számítja ki. Számok esetén not (" !" ) a szám bitjeinek bitenkénti nem m veletét számítja ki. - expr
expr1 * expr2 expr1 div expr2 expr1 mod expr2 expr1 / expr2 expr1 << expr2 expr1 >> expr2 expr1 + expr2 expr1 - expr2 expr1 = expr2 expr1 <> expr2 expr1 < expr2 expr1 <= expr2 expr1 > expr2 expr1 >= expr2 expr1 & expr2 expr1 | expr2 expr1 ^ expr2 ( expr ) (egyoperandusú negálás operátora) (szorzó operátor) (egész osztó operátor) (egész maradék képz operátor (valós osztó operátor) (egész bit balra toló operátor) (egész bit jobbra toló operátor) (összeadó operátor) (kivonó operátor) (egyenl ségvizsgáló operátor) (egyenl tlenségvizsgáló operátor) (kisebb mint összehasonlító operátor) (kisebb vagy egyenl összehasonlító operátor) (nagyobb mint összehasonlító operátor) (nagyobb vagy egyenl összehasonlító operátor) (logikai/bool ÉS operátor) (logikai/bool VAGY operátor) (logikai/bool XOR operátor) (operátor precedencia megváltoztatás)

A HLA számos más konstans operátort is támogat. Emellett a fenti operátorok némelyikét az operandus típusokra átértelmezik. Megjegyezzük, hogy numerikus (integer) operandusokkal a HLA teljes mértékben támogatja a 128-bites aritmetikát. A részleteket lásd a HLA kézikönyvben.

Randall Hyde dokumentumának magyarítása

Page 7

HLA Documentation

4.11

A program szerkezete

Egy HLA program a következ általános szintaxist követi:
program azonosító ; deklarációk begin azonosító ; utasítások end azonosító ;

A három ,,azonosító"-nak azonosnak kell lennie. A deklarációs rész (deklarációk) type, const, val, var, static, uninitialized, readonly, segment, procedure és macro definíciókból áll. A deklarációs részben akármilyen számú ilyen szakasz, akármilyen sorrendben megjelenhet, egy-egy szakasz többször is. Ha egy olyan könyvtári modult akarunk írni, amely csak eljárásokat tartalmaz, f programot nem, egy HLA unitot használunk. A unitok szintaxisa majdnem azonos a programokéval, csak itt nincs a unithoz tartozó BEGIN, pl.
unit TestPgm; procedure LibraryRoutine; begin LibraryRoutine; << stb. >> end LibraryRoutine; end TestPgm;

4.11.1

Eljárás deklarációk
Az eljárások deklarációi csaknem megegyeznek a program deklarációival.
procedure identifier; noframe; begin identifier; statements end identifier;

Vegyük észre, hogy a HLA nagyon gazdag szintaktikus lehet ségeket kínál. A fenti minta annak a szintaxisnak felel meg, amely leginkább hasonlít a többi assembler által használt eljárás megvalósítási módhoz. A HLA eljárásai lehet vé tesznek paramétereket, helyi változók deklarálását, és sok olyan eszközt, amit a jelen dokumentum nem ír le. Részletekért lásd a HLA Kézikönyvet. Jegyezzük meg, és ez nagyon fontos, hogy a NOFRAME paraméternek jelen kell lennia a PROCEDURE deklarációjában. Enélkül a HLA további kódot ad az eljáráshoz és az minden bizonnyal nem várakozásunknak megfelel en fog m ködni (valójában, a beszúrt kód a program elhalásához vezet). Egy példa eljárás:
procedure ProcDemo; @noframe; begin ProcDemo; add( 5, eax ); ret(); end ProcDemo;

Page 8

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv

4.12

Deklarációk
A programok, unitok, eljárások, módszerek és iterátorok mind rendelkeznek egy deklarációs szakasszal. Az osztályoknak és a névtereknek is van deklarációs szakasza, de az kicsit korlátozott. A deklarációs szakasz egy vagy több komponenst tartalmaz a következ k közül (amelyeket más dolgokhoz hasonlóan ez a dokumentum nem tárgyal): · · · · 'type' szakasz. 'const' szakasz. 'static' szakasz. Egy eljárás.

A szakaszok sorrendje mellékes; feltéve, hogy a program valamennyi azonosítót annak els használata el tt definiálja. Emellett, mint fentebb megjegyeztük, az egyes szekciók többször is el fordulhatnak egyazon deklarációs részben. Például, a két 'const' szakasz a következ eljárásdeklarációban tökéletesen szabályos:
program TwoConsts; const MaxVal := 5; type Limits: dword[ MaxVal ]; const MinVal := 0; begin TwoConsts;

end TwoConsts;

4.12.1

A 'type' szakasz

A 'type' szakaszban deklarálhatunk felhasználói adattípusokat. A type szakasz a deklarációs részben jelenik meg és a type kulcsszóval kezd dik. Mindaddig tart, amíg egy másik deklarációs kulcsszó (pl. const, var, vagy val) vagy a begin kulcsszó el nem fordul. Egy tipikus típusdefiníció egy azonosítóval kezd dik, amelyet kett spont és a típusdefiníció követ. A következ bekezdés néhány szabályos típusdefiníciót mutat be.
id1 : id2; // Definiáld id1-et ugyanolyan típusúnak, mint id2. id1 : id2 [ dim_list ]; // Definiáld id1-et id2 típusú tömbként. id1 : record // Definiáld id1-et rekord típusként. mez _deklarációk endrecord;

4.12.2 A 'const' szakasz
A HLA program 'CONST' szakaszában deklarálhatunk konstansokat. Tilos a fordítás során kés bb a konstans értékét megváltoztatni. Természetesen futási id alatt a konstansok static értékkel rendelkeznek. A konstansdeklarációs szakasz a const kulcsszóval kezd dik és konstansdefiníciók sorozatával folytatódik. A konstansdeklarációs szakasz a const, var, type, vagy val, stb. kulcsszavak valamelyikének el fordulásáig tart. A konstansdefiníciók a következ bekezdésekben mutatott alakokat vehetik fel.
id := expr; // Az expr értékét és típusát rendeli hozzá id-hez id1 : id2 := expr; // Létrehoz egy id2 típusú, expr érték id1 konstanst.

Randall Hyde dokumentumának magyarítása

Page 9

HLA Documentation Megjegyezzük, hogy a HLA számos olyan konstans típust támogat, amelyeket ez a szakasz nem említ meg (például tömb és rekord állandók valamint fordítási-id változók). A részleteket lásd a HLA Kézikönyvben.

4.12.3

A 'static' szakasz
A static szakasz lehet vé teszi, hogy statikus változókat deklaráljon, amelyeket aztán a programkód futási id ben használhat. A következ bekezdések néhány olyan formát mutatnak, amelyek megengedettek a STATIC szakaszban. Mint általában, lásd a HLA Kézikönyvét számos olyan tulajdonság leírásáért, amelyeket a HLA támogat a STATIC szakaszban.
static

id1 : id2; // Egy id2 típusú id1 változót deklarál id1 : id2 := expr; // Egy id2 típusú id1 változót deklarál és expr érték re állítja id1 : id2[ expr ]; // Egyid2 típusú, expr elem id1 változót deklarál

4.12.3.1

A @NOSTORAGE kulcsszó

A @nostorage kulcsszó hatására a HLA hozzárendeli a szegmensen belüli offset pillanatnyi értékét a változóhoz, de nem foglal tárterületet az objektum számára. Ez a kulcsszó tehát valójában egy álnevet kreál a static szakasz következ objektuma számára. Tekintsük a következ példát:
static b: w: d: byte; @nostorage; word; @nostorage; dword;

Mivel a b és w változók mindegyike után a @nostorage kulcsszó áll, a HLA nem foglal tárterületet ezen változók számára. A d változó mellett nem áll a @nostorage kulcsszó, így a HLA négy bájtot foglal le a változó számára. A b és w változók, mivel nincs hozzájuk rendelve tárterület, ugyanazon a címen érhet k el, mint a d változó.

4.12.3.2

Az @EXTERNAL kulcsszó

Az external kulcsszó arra ad lehet séget, hogy más fájlokban deklarált statikus változókra hivatkozzunk. Mint az eljárások external kulcsszava esetén is, két különböz szintaxis fordulhat el a változó deklarációja után:
varName: varType; @external; varName: varType; @external ( "external_Name" );

A fenti els forma a változó nevét használja internal és external névként is. A második forma esetén a HLA bels névként használja varName­t a küls modulokban pedig az external_Name nevet rendeli ehhez a változóhoz. Az external kulcsszó mindig a utolsó az adott változóhoz társított kulcsszavak között. Ha egy küls objektum változó definíciója a forrásfájlban egy external deklaráció után jelenik meg, ezt a HLA úgy értelmezi, hogy ez egy olyan nyilvános változó, amelyet más modulok is használhatnak (az alapértelmezés szerint a változók az adott forrás fájlban lokálisak). Ez az egyetlen módja annak, hogy egy változót publikussá tegyünk, azaz hogy azt más modulok is használhassák. Általában az external deklarációkat egy fejléc (header) fájlba tesszük, amelyet valamennyi (a változót használni kívánó) modul becsatol, és hasonlóan becsatol a változó deklarációját használó forrásfájl is.

Page 10

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv

4.12.4 Makrók
A HLA makrókifejtési képessége az egyik legfeljlettebb a hasonló fordítóprogramok között. A HLA makrói kulcsszerepet töltenek be a HLA nyelv kiterjesztésekor. Ha gyakran használ makrókat, érdemes megtanulnia a HLA kézikönyb l a HLA makró képességeit. Ez a fejezet a HLA korlátozott ,,Standard Macro" lehet ségeit ismerteti, ami a hasonló assemblerek lehet ségeivel egyenérték . Egy program deklarációs részében a következ szintaxissal adhat meg makrókat:
#macro azonosító ( opcionális_paraméterlista );
utasítások

#endmacro;

Példa:
#macro MyMacro; ?i = i + 1; #endmacro;

Az esetleges paraméterlista egy vagy több azonosítóból áll, vessz vel elválasztva. A HLA automatikusan ,,text" típust rendel a makró paraméterekhez (kivéve egy alább bemutatott speciális esetet). Példa:
#macro MacroWParms ( a, b, c ); ?a = b + c; #endmacro;

Ha egy makró nem használ paramétereket, az azonosítót pontosvessz követi (azaz nincs zárójel vagy paraméterazonosító). Lásd az els példát ebben e fejezetben paraméter nélküli makróként. Szükségünk lehet olyan szimbólumok definiálására, amelyek lokálisak a makróhívásra nézve (azaz a makró minden egyes hívása egy egyedi szimbólumot eredményez az adott azonosító esetén). A helyi azonosítók listája ezt lehet vé teszi. Helyi azonosítók deklarálásához egyszer en írjunk a paraméter lista után (a zárójel után, de a pontosvessz el tt) egy kett spontot és változók vessz vel elválasztott listáját, pl.
#macro ThisMacro(parm1) :id1,id2; ...

A HLA automatikusan átnevezi az ebben a listában megjelen szimbólumokat úgy, hogy az új név biztosan egyedi legyen a programban. A HLA az egyedi szimbólumokat "_XXXX_" alakban képzi, ahol XXXX egy hexadecimális érték. Hogy a HLA biztosan egyedi szimbólumokat állíthasson el , kerüljük az ilyen szimbólumok használatát saját programunkban (általában, az aláhúzással kezd d és végz d szimbólumok a fordítóprogram és a HLA standard könyvtár számára vannak fenntartva). Például:
#macro LocalSym : i,j; j: cmp(ax, 0) jne( i ) dec( ax ) jmp( j ) i: #endmacro;

Randall Hyde dokumentumának magyarítása

Page 11

HLA Documentation Egy makró hívásához egyszer en megadjuk annak nevét és a megfelel paramétereket. Ha csak nem változó számú paramétert írunk el (tömb szintaxis használatával) a makróban, az aktuális paraméterek számának pontosan meg kell egyeznia a formális paraméterek számával. Ha változó számú paramétert írunk el a makróban, az aktuális paraméterek száma nem lehet kisebb a formális paraméterek számánál (a tömb paramétert nem számítva). Az aktuális paraméterek egy karakterfüzérb l állnak, amely a határoló vessz ig vagy hátsó zárójelig terjed és az utóbbit már nem tartalmazza, pl.
example( v1, x+2*y )
"v 1 " az els paraméternek megfelel szöveg, "x+2*y" a második paraméternek megfelel szöveg. Megjegyezzük, hogy a HLA a kód kifejtésekor lehámozza a bevezet és befejez nem-nyomtatódó és vezérl karaktereket. Az el bbi példát a HLA a következ vé fejti ki:

?v1 := x+2*y;

Ha (kiegyensúlyozott) zárójelek szerepelnek az aktuális paraméterek listáján, a HLA nem tekinti a bels záró zárójelet a makró paraméter lezárásának. Azaz, teljesen szabályos a következ :
example( v1, ((x+2)*y) )

Ennek kifejtése:
?v1 := ((x+2)*y);

4.12.5 Az #Include direktíva
Mint a legtöbb hasonló nyelvnek, a HLA-nak is van forrásnyelvi fájl becsatolására vontakozó direktívája, amely a fordítás során a forrásfájl belsejébe beszúr egy másik fájlt. A HLA #INCLUDE direktívája nagyon hasonló a C/C++ azonos nev pragmájához, és mindkett t els sorban ugyanarra a célra használjuk: könyvtári fejléc fájlokat szúrunk be saját programunkba. A HLA include direktívájának szintaxisa:
#include( szöveg_kifejezés );

4.12.6 Az #IncludeOnce direktíva
Ha összetett fejléc fájlokat készítünk, különösen könyvtári fejléc fájlok esetén, szükséges lehet #INCLUDE("file") direktívát beírni más fejléc fájlokba is. Ez általában nem okoz gondot, a HLA (legalább 256 szintig) megengedi fájlok egymásba ágyazását. Azonban, ha csak nem vagyunk rendkívül el relátók fájljaink szervezésében, könnyen létrehozhatunk egy olyan ,,beszúrási hurkot", amely abban nyilvánul meg, hogy az egyik fájl beszúr egy másikat, amelyik viszont az els t szeretné beszúrni. Ha egy ilyen programot megpróbálunk lefordítani, az a fordításkor egyfajta ,,végtelen ciklust" eredményez. Ez nyilván nem kívánatos. E probléma elkerülésére használható az #INCLUDEONCE direktíva. Az el z höz képest az a különbség, hogy a HLA nyilvántartja, hogy mely fájlokat dolgozott fel az #INCLUDE és az #INCLUDEONCE direktívák használatával és nem dolgozza fel újból a fejléc fájlt ha azt az #INCLUDEONCE direktívával szúrtuk be.

Page 12

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv Amikor a HLA végrehajtja az #INCLUDEONCE direktívát, el ször összehasonlítja annak szöveg paraméterét az el z leg feldolgozott #INCLUDE és #INCLUDEONCE direktívák szövegeib l összeállított lista elemeivel. Ha az azonos a lista valamely elemével, a HLA figyelmen kívül hagyja az #INCLUDEONCE direktívát; ha a fejléc file neve nem szerepel a bels listán, akkor a HLA hozzáadja a fájlnevet a listához és beszúrja a fájlt.

4.12.7 Az #asm..#endasm és #emit direktívák
A HLA távolról sem tökéletes. Vannak hiányzó utasításai (néhány szándékosan, néhány lustaságból, néhány tudatlanságból maradt ki). Például, a HLA jelenleg nem támogatja az SSE utasításkészletet. Viszont, két olyan kilépési mechanizmust is biztosít, amelyek lehet vé teszik, hogy bármi olyat megtehessünk, amit a HLA fordítási eredményét feldolgozó assembler program (pl. MASM) megenged. Az els ilyen mechanizmus az #ASM..#ENDASM szakasz. Az assembly blokk szintaxisa a következ :
#asm << szöveg amit << közvetlenül átadunk << a MASM kimen << adatfájlnak. #endasm
>> >> >> >>

Az #ASM és #ENDASM direktívák között megjelen szöveg teljes egészében és változatlanul beíródik a HLA által készített .ASM fájlba. A MASM (vagy más assembler, amit használ) lesz a felel s ennek a kódnak a fordításáért. Természetesen, az assembly blokkban olyan kódot kell megadnia, amit az assembler képes lefordítani, vagy az assembler fordítási hibát fog jelezni, amikor a kóddal találkozik. A másik ilyen kilépési mechanizmus az #EMIT direktíva. Ennek formája:
#emit( szöveges_kifejezés )

.#endasm

A HLA értelmezi a szöveges kifejezést és beírja a szöveges kifejezést a keletkez .ASM fájlba. Az #asm. blokk és az #emit direktíva részletes leírását és az azokkal kapcsolatos korlátozásokat lásd a HLA kézikönyvben.

4.12.8 A feltételes fordítás utasításai (#if)
A feltételes fordítás utasításai a HLA-ban a következ szintaxissal rendelkeznek:
#if( állandó_logikai_kifejezés ) << Fordítandó utasítások >> << ha a fenti kifejezés igaz>> #elseif (állandó_logikai_kifejezés ) << Fordítandó utasítások ha >> << a közvetlenül ez el tt álló >> << kifejezés igaz és az els >> << kifejezés fent hamis. >> #else << Fordítandó utasítások ha >> << mindkét fenti kifejezés hamis. >> #endif

Randall Hyde dokumentumának magyarítása

Page 13

HLA Documentation

Az #ELSEIF és #ELSE utasítások opcionálisak. Mint várható, egynél több #ELSEIF is el fordulhat ugyanabban a feltételes direktívában. Más assemblerekt l és magas szint nyelvekt l eltér en, a HLA feltételes direktívái mindenütt el fordulhatnak, ahol nem-nyomtatódó jelek lehetnek. Még az utasítások közepén is! Bár ilyen direktíváknak az utasításokba való ilyen beágyazása nem ajánlott (mivel nehezen olvashatóvá teszi a kódot), jó tudni, hogy ezeket a direktívákat makrókban is el lehet helyezni és azután az utasítás operandusát makróhívással lehet helyettesíteni. Fontos megjegyezni e direktíváról, hogy az #IF és #ELSEIF direktívákban szerepl konstans kifejezéseknek logikai típusúaknak kell lenniük, különben a HLA hibajelzést ad. Bármely, logikai értéket eredményez konstans kifejezés elfogadható e helyen. Ne tévesszük szem el l, hogy a feltételes fordítási direktívák fordítási id ben és nem futási id alatt hajtódnak végre. Ezeket a direktívákat nem használhatja döntések meghozatalára amikor a programja már ténylegesen fut.

5

A 80x86 utasításkészlete a HLA-ban
A HLA és a standard 80x86 assembly nyelv között az egyik legnyilvánvalóbb különbség a gépi utasítások szintaxisában van. A két legfontosabb eltérés, hogy a HLA függvény-szer jelölést használ és hogy a HLA-ban (forrás,cél) sorrendben szerepelnek az operandusok az Intelnél megszokott (cél,forrás) sorrend helyett.

5.1

Operandus nélküli (Nulla operandusú) utasítások
A következ utasításoknak nem szükséges operandus. Az ilyen utasításoknak kétféle szintaxis is megengedett:
instr; instr();

A nulla operandusú utasítások mnemonikjai aaa, aad, aam, aas, cbw, cdq, clc, cld, cli, cmc, cmpsb, cmpsd, cmpsw, cpuid, cwd, cwde, daa, das, insb, insd, insw, into, iret, iretd, lahf, leave, lodsb, lodsd, lodsw, movsb, movsd, movsw, nop, outsb, outsd, outsw, popad, popa, popf, popfd, pusha, pushad, pushf, pushfd, rdtsc, rep.insb, rep.insd, rep.insw, rep.movsb, rep.movsd, rep.movsw, rep.outsb, rep.outsd, rep.outsw, rep.stosb, rep.stosd, rep.stosw, repe.cmpsb, repe.cmpsd, repe.cmpsw, repe.scasb, repe.scasd, repe.scasw, repne.cmpsb, repne.cmpsd, repne.cmpsw, repne.scasb, repne.scasd, repne.scasw, sahf, scasb, scasd, scasw, stc, std, sti, stosb, stosd, stosw, wait, xlat

5.2

Általános aritmetikai és logikai utasítások
Ezek az utasítások az adc, add, and, mov, or, sbb, sub, test, és xor. Ezek mind ugyanazt az alapformát használják (az alábbi példákban helyettesítse az "adc" utasításnevet a megfelel utasításnévvel): Alapforma: adc( forrás, cél ); Megengedett speciális formák:

Page 14

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv

adc( Reg8, Reg8 ); adc( Reg16, Reg16 ); adc( Reg32, Reg32 ); adc( const, Reg8 ); adc( const, Reg16 ); adc( const, Reg32 ); adc( const, mem ); adc( Reg8, mem ); adc( Reg16, mem ); adc( Reg32, mem ); adc( mem, Reg8 ); adc( mem, Reg16 ); adc( mem, Reg32 ); adc ( Reg8, AnonMem ); adc( Reg16, AnonMem ); adc( Reg32, AnonMem ); adc ( AnonMem, Reg8 ); adc( AnonMem, Reg16 ); adc( AnonMem, Reg32 );

Figyelem: az "adc( const, mem )" formájú utasítások esetén, ha a memóriahelyhez nincs hozzárendelve méret vagy típus, a memória operandus méretét explicite meg kell határozni, pl. "adc(5,(type byte [eax]));"

5.3

Az XCHG utasítás
Az xchg utasítás a következ szintatikus változatokban létezhet: Alap alak:

xchg( forrás, cél );

Speciális alak:
xchg( xchg( xchg( xchg( xchg( xchg( xchg( xchg( xchg( xchg( Reg8, Reg8 ); Reg8, mem ); Reg8, AnonMem); mem, Reg8 ); AnonMem, Reg8 ); Reg16, Reg16 ); Reg16, mem ); Reg16, AnonMem); mem, Reg16 ); AnonMem, Reg16 );

xchg( Reg32, Reg32 ) xchg( Reg32, mem )

Randall Hyde dokumentumának magyarítása

Page 15

HLA Documentation
xchg( Reg32, AnonMem); xchg( mem, Reg32 ); xchg( AnonMem, Reg32 );

5.4

A CMP utasítás
A "cmp" utasítás a következ általános alakot használja: Alap forma:
cmp ( BalOperandus, JobbOperandus );

Speciális alakok:
cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( cmp( Reg8, Reg8 ); Reg8, mem ); Reg8, AnonMem ); mem, Reg8 ); AnonMem, Reg8 ); Reg8, const ); Reg16, Reg16 ); Reg16, mem ); Reg16, AnonMem ); mem, Reg16 ); AnonMem, Reg16 ); Reg16, const ); Reg32, Reg32 ); Reg32, mem ); Reg32, AnonMem ); mem, Reg32 ); AnonMem, Reg32 ); Reg32, const );

cmp( mem, const );

Vegyük észre, hogy a CMP utasítás operandusai ,,cél,forrás" sorrendben vannak, a szokásos ,,forrás,cél" helyett (azaz az operandusok abban a sorrendben vannak, ahogyan a MASM várja azokat). Ez azért van így, hogy lehet vé tegye az utasítás mnemonic intuitív használatát (azaz, a CMP-t általában úgy olvasssuk, hogy ,,hasonlítsd a célt a forráshoz""). Ez a keveredést azzal akarjuk elkerülni, hogy az operandusokat ,,bal operandusnak" és ,,jobb operandusnak" nevezzük. A bal és a jobb egyértelm en jelöli az összehasonlító operátor két oldalán az operandusok elhelyezkedését, pl. "<=" (e.g., "left <= right"). A "cmp( mem, const )" formájú utasítások esetén a memória operandusnak típussal vagy mérettel kell rendelkeznie. Ha névtelen memóriára hivatkozunk, a memóriahelyet típuskényszerítéssel kell megadni, pl. "cmp( (type word [ebp-4]), 0 );".

5.5

A szorzó (Multiply) utasítások
A HLA a 80x86 ,,MUL" és ,,IMUL" utasításainak számos változatát támogatja. Ezeknek a formája a következ lehet: A szokásos szintaxis:

Page 16

Version: 5/7/02

Written by Randall Hyde

mul ( reg8 ); mul( reg16); mul( reg32 ); mul ( mem ); mul( reg8, al ); mul( reg16, ax ); mul( reg32, eax ); mul ( mem, al ); mul( mem, ax ); mul ( mem, eax ); mul ( AnonMem, ax ); mul ( AnonMem, dx: ax ); mul ( AnonMem, edx: eax ); imul( imul( imul( imul( reg8 ); reg16); reg32 ); mem );

imul( reg8, al ); imul( reg16, ax ); imul( reg32, eax ); imul( mem, al ); imul( mem, ax ); imul( mem, eax ); imul( AnonMem, ax ); imul( AnonMem, dx:ax ); imul( AnonMem, edx:eax ); intmul( const, Reg16 ); intmul( const, Reg16, Reg16 ); intmul( const, mem, Reg16 ); intmul( const, AnonMem, Reg16 ); intmul( const, Reg32 ); intmul( const, Reg32, Reg32 ); intmul( const, mem, Reg32 ); intmul( const, AnonMem, Reg32 ); intmul( Reg16, Reg16 ); intmul( mem, Reg16 ); intmul( AnonMem, Reg16 ); intmul ( Reg32, Reg32 ); intmul ( mem, Reg32 ); intmul ( AnonMem, Reg32 );

Kiterjesztett szintaxis:
mul( const, al ); mul( const, ax ); mul( const, eax );

Randall Hyde dokumentumának magyarítása

Page 17

HLA Documentation
imul( const, al ); imul( const, ax ); imul( const, eax );

Az els és legfontosabb tudnivaló a HLA szorzó utasításáról, hogy a HLA különböz utasítás nevet (mnemonik) használ a kiterjesztett pontosságú és az egyszeres pontosságú szorzás esetén (IMUL és INTMUL). A standard MASM mindkét utasításra ugyanazt az utasításnevet használja. Két oka volt a HLA ilyen szintaxis változtatásának. El ször, hogy valahogyan meg kell különböztetni a "mul( const, al )" és "intmul(const, al )" utasításokat (hasonlóan az AX és EAX regiszterekre vonatkozó utasításokhoz). A másik, hogy az INTMUL utasítás viselkedése lényegesen eltér az IMUL utasításétól, így van értelme ezekre az utasításokra eltér utasításnevet használni. A kiterjesztett szintaxisú utasítások egy static változót hoznak létre, annak a megadott konstanst adják kezd értékül és ennek a változónak a címét adják meg a MUL vagy IMUL utasítás forrás operandusaként.

5.6

Az osztó (Divide) utasítások
A HLA a 80x86 DIV és IDIV utasításainak számos változatát támogatja. Ezek formái: Alapforma:
div( source ); div( source, dest ); mod( source ); mod( source, dest ); idiv( source ); idiv( source, dest ); imod( source ); imod( source, dest );

Speciális formák:

div( div( div( div(

reg8 ); reg16); reg32 ); mem );

div( reg8, ax ); div( reg16, dx:ax); div( reg32, edx:eax ); div( mem, ax ); div( mem, dx:ax); div( mem, edx:eax ); div ( AnonMem, ax ); div ( AnonMem, dx: ax ); div ( AnonMem, edx:eax ); mod( reg8 ); mod( reg16); mod( reg32 ); mod( mem );

Page 18

Version: 5/7/02

Written by Randall Hyde

HLA Language Reference
mod( reg8, ax ); mod( reg16, dx:ax); mod( reg32, edx:eax ); mod( mem, ax ); mod( mem, dx:ax); mod( mem, edx:eax ); mod ( AnonMem, ax ); mod ( AnonMem, dx: ax ); mod( AnonMem, edx:eax ); idiv( idiv( idiv( idiv( reg8 ); reg16); reg32 ); mem );

idiv( reg8, ax ); idiv( reg16, dx:ax); idiv( reg32, edx:eax ); idiv( mem, ax ); idiv( mem, dx:ax); idiv( mem, edx:eax ); idiv( AnonMem, ax ); idiv( AnonMem, dx:ax ); idiv( AnonMem, edx: eax ); imod( reg8 ); imod( reg16); imod( reg32 ); imod ( mem ); imod( reg8, ax ); imod( reg16, dx:ax); imod( reg32, edx:eax ); imod( mem, ax ); imod( mem, dx:ax); imod( mem, edx:eax ); imod ( AnonMem, ax ); imod ( AnonMem, dx: ax ); imod( AnonMem, edx:eax );

Kiterjesztett szintaxis:

div( const, ax ); div( const, dx:ax ); div( const, edx:eax ); mod( const, ax ); mod( const, dx:ax ); mod( const, edx:eax );

Randall Hyde dokumentumának magyarítása

Page 19

idiv( const, ax ); idiv( const, dx:ax ); idiv( const, edx:eax ); imod( const, ax ); imod( const, dx:ax ); imod( const, edx:eax );

A cél operandus a 80x86 "div" és "idiv" utasításaiban mindig alapértelmezett (AX, DX:AX, vagy EDX:EAX ). A HLA a program könnyebb olvashatósága érdekében megengedi a céloperandus megadását (bár a cél operandus megadása opcionális). A HLA osztási utasítás támogat egy olyan kiterjesztett szintaxist, amely megengedi, hogy osztóként (forrás operandusként) konstansot használjunk. A HLA a static adat szegmensben foglal le egy tárterületet, a megadott konstanst használja annak kezd értékéül, majd az akkumlátort ezzel az újonnan meghatározott memóriacím tartalmával osztja.

5.7

Egyoperandusú aritmetikai és logikai utasítások
Ezek az utasítások a dec, inc, neg, és not. Ezek általános formája (helyettesítsük a megadott mnemonikot a megfelel vel): Alapforma:
dec ( dest ); A megengedett speciális formák:

dec ( Reg8 ); dec ( Reg16 ); dec ( Reg32 ); dec ( mem );

Megjegyzés: ha m e m típus és méret nélküli memóriahely (azaz névtelen memóriahely), explicit módon meg kell adni annak típusát, pl. "dec( (type word [edi]));"

5.8

Biteltoló és -forgató utasítások
Ezek az utasítások a következ k: RCL, RCR, ROL, ROR, SAL, SAR, SHL, és SHR. Ezek az utasítások a következ alap szintaxissal rendelkeznek, a megfelel mnemonik helyettesítése után. Alap forma:
shl ( szám, cél );

Speciális forma:

shl ( const, Reg8 ); shl ( const, Reg16 ); shl ( const, Reg32 );

Randall Hyde dokumentumának magyarítása

Page 20

HLA zsebkönyv HLA Language Reference
shl( const, mem ); shl( cl, Reg8 ); shl( cl, Reg16 ); shl( cl, Reg32 ); shl( cl, mem );

A "const" operandus egy el jel nélküli egész állandó zérus és a cél operandus bitszáma által meghatározott maximum között. A memória operandust használó operandusoknak típussal vagy mérettel kell rendelkezniük, azaz ha névtelen memóriahelyet használunk, típuskényszerítést kell alkalmaznunk: shl( 2, (type dword [esi]));

5.9

A kétszeres pontosságú biteltoló utasítások
Ezen utasítások általános formája a következ (az alábbiakban SHRD-t is használhat SHLD helyett): Általános forma:

shld( szám, forrás, cél );

Speciális forma:

shld( const, Reg16, Reg16 ); shld( const, Reg16, mem ); shld( const, Reg16, AnonMem ); shld( cl, Reg16, Reg16 ); shld( cl, Reg16, mem ); shld( cl, Reg16, AnonMem ); shld( const, Reg32, Reg32 ); shld( const, Reg32, mem ); shld( const, Reg32, AnonMem ); shld( cl, Reg32, Reg32 ); shld( cl, Reg32, mem ); shld( cl, Reg32, AnonMem );

5.10

A lea utasítás
Ez az utasítás a következ szintaxist használja:
lea( Reg32, memory ); lea( Reg32, AnonMem ); lea( Reg32, ProcID );

lea( Reg32, LabelID );

Kiterjesztett szintaxis: Randall Hyde dokumentumának magyarítása Page 21

HLA Documentation
lea( lea( lea( lea( lea( lea( memory, Reg32 ); AnonMem, Reg32 ); ProcID, Reg32 ); LabelID, Reg32 ); StringConstant, Reg32 ); const ConstExpr, Reg32 );

A ,,lea" utasítás a megadott 32-bites regiszterbe tölti a megadott memória operandus, eljárás vagy utasítás címét. Megjegyezzük, hogy a kiterjesztett szintaxist használva az operandusok formáját megfordíthatja. Mivel pontosan egy operandusnak regiszter típusúnak kell lennie, a kétféle forma között semmi kétség nem merül fel (ez utóbbi szintaxis azok kedvéért szerepel, akik panaszkodtak a (reg,memory) szintaxis miatt). Természetesen az a jó programozói stílus, ha csak az egyik formát használja programjában (vagy reg,memory vagy memory,reg). Megjegyzés: a HLA nem támogatja azt a LEA utasítást, amelyik 16 bites címet tölt be egy 16 bites regiszterbe. Ez a forma nem igazán használható, amikor egy 32 bites programot futtatunk egy 32 bites operációs rendszeren.

5.11

Az el jeles és nulla módú hosszkiterjeszt utasítások
A HLA MOVSX és MOVZX utasítások szintaxisa a következ : Általános alak: movsx( source, dest ); movzx( source, dest ); Speciális alakok:

movsx ( Reg8, movsx ( Reg8, movsx( Reg16, movsx ( mem8, movsx ( mem8, movsx( mem16, movzx ( Reg8, movzx ( Reg8, movzx( Reg16, movzx ( mem8, movzx ( mem8, movzx( mem16,

Reg16 Reg32 Reg32 Reg16 Reg32 Reg32 Reg16 Reg32 Reg32 Reg16 Reg32 Reg32

); ); ); ); ); ); ); ); ); ); ); );

Ezek az utasítások el jellel (MOVSX) vagy nullával (MOVZX) kiterjesztve másolják a forrás operandust a cél operandusba.

5.12

A Push és Pop (veremkezel ) utasítások
Ezen utasítások általános formája a következ :
pop( reg16 ); pop( reg32 ); pop( mem ); push( Reg16 ); push( Reg32);

Page 22

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv HLA Language Reference
push( memory ); pushw( pushw( pushw( pushw( pushd( pushd( pushd( pushd( Reg16 ); memory ); AnonMem ); Const ); Reg32 ); memory ); AnonMem ); Const );

Ezek az utasítások a veremtárolóba teszik vagy onnét el veszik a meghatározott operandust.

5.13

Eljárás hívások
Ha adott egy "MyProc" nev eljárás vagy az eljárás címét tartalmazó DWORD változó, az eljárást a következ paranccsal lehet hívni:
call( MyProc );

A HLA ténylegesen számos más szintaxisú eljáráshívást is támogat, beleértve olyanokat is, amelyek automatikusan paramétereket löknek a veremtárolóba. A részleteket lásd a HLA Kézikönyvében.

5.14

A ret utasítás
A RET( ) utasítás kétféle szintaktikus formát enged meg:
ret( ); ret ( egész_konstans_kifejezés );

Az els forma egyszer en a 80x86 RET utasítást adja ki, a második pedig a 80x86 RET utasítását a (veremtárolóban rzött paraméterek eltávolítására használt) numerikus kostans kifejezés értékével.

5.15

Az ugró (jmp) utasítások
A HLA "jmp" utasítások a következ szintaxist követik:
jmp Label; jmp ProcedureName; jmp( dwordMemPtr ); jmp( anonMemPtr ); jmp( reg32 );

A "Label" a folyó eljárás egy utasítás címkéjét jelenti. (A mostani verzióban nem megengedett egy másik eljárásban lev címkére ugrani. A következ verziókban ez a korlátozás enyhülhet.) Az utasításcímke egyedi azonosító (az adott eljáráson belül), amelyet a kett spont követ, pl.

Randall Hyde dokumentumának magyarítása

Page 23

VégtelenCiklus: << A végtelen cikluson belüli kód>> jmp VégtelenCiklus;

Egy eljárásra ugrani annyit jelent, mint a meghatározott eljárás els utasítására adni át a vezérlést. A programozó felel ssége, hogy a szükséges paramétereket és a visszatérési címet a veremtárolóba tegye. Ezek az utasítások egy üres sttringet adnak meg ,,returns" értékként.

5.16

A feltételes ugró utasítások
Ezek az utasítások: JA, JAE, JB, JBE, JC, JE, JG, JGE, JL, JLE, JO, JP, JPE, JPO, JS, JZ, JNA, JNAE, JNB, JNBE, JNC, JNE, JNG, JNGE, JNL, JNLE, JNO, JNP, JNS, JNZ, JCXZ, JECXZ, LOOP, LOOPE, LOOPZ, LOOPNE, and LOOPNZ. Valamenyi utasítás a következ általános formát követi (a ,,JA"-t a megfelel paranccsal helyettesítve).
ja
HelyiCímke;

"HelyiCímke "

a folyó eljárásban definált utasításcímke

Megjegyzés: a HLA fordítási folyamat sajátságai miatt kerülje a JCXZ, JECXZ, LOOP, LOOPE, LOOPZ, LOOPNE, és LOOPNZ utasítások használatát. A többi feltételes ugró utasítástól eltér en, ezen utasítások relatív címtartománya a nagyon korlátozott +/- 128 tartomány. Sajnálatos módon, a HLA nem veszi észre, ha a relatív cím ezen a tartományon kívül esik (ezt a feladatot a MASM látja el), azaz ha egy ilyen címtartományhiba lép fel, a HLA nem tud erre figyelmeztetni. A MASM fordítás nem fog sikerülni, és nehéz kitalálni, mi is a hiba oka. Szerencsére ezek az utasítások könnyen és általában hatékonyabban megvalósíthatók más 80x86 utasításokkal, ezért ez nem igazán probléma.

5.17

A feltételes Set utasítások
Ilyen utasítások a következ k: SETA, SETAE, SETB, SETBE, SETC, SETE, SETG, SETGE, SETL, SETLE, SETO, SETP, SETPE, SETPO, SETS, SETZ, SETNA, SETNAE, SETNB, SETNBE, SETNC, SETNE, SETNG, SETNGE, SETNL, SETNLE, SETNO, SETNP, SETNS, and SETNZ. Ezek ilyen alapformát vehetnek fel (a megfelel mnemonikot helyettesítve seta helyére):
seta( Reg8 ); seta( mem ); seta( AnonMem );

5.18

A feltételes move utasítások
Ilyen utasítások a következ k: CMOVA, CMOVAE, CMOVB, CMOVBE, CMOVC, CMOVE, CMOVG, CMOVGE, CMOVL, CMOVLE, CMOVO, CMOVP, CMOVPE, CMOVPO, CMOVS, CMOVZ, CMOVNA, CMOVNAE, CMOVNB, CMOVNBE, CMOVNC, CMOVNE, CMOVNG, CMOVNGE, CMOVNL, CMOVNLE, CMOVNO, CMOVNP, CMOVNS, and CMOVNZ. Ezek a következ általános szintaxist követik:
CMOVcc ( src, dest );

A lehetséges operátorok:

Randall Hyde dokumentumának magyarítása

Page 24

HLA zsebkönyv

CMOVcc( CMOVcc( CMOVcc( CMOVcc(

reg16, reg1 6 ); reg32, reg3 2 ); mem16, reg16 ); mem32, reg32 );

Ezek az utasítások csak akkor mozgatják az adatokat, ha (a cc feltétellel) meghatározott feltétel igaz. Ha a feltétel hamis, ezen utasítások üres m veletként (no-operation) viselkednek.

5.19

Adat be- és kiviteli utasítások
Az "in" és "out" utasítások szintaxisa a következ :
in( port, al ); in( port, ax ); in( port, eax ); in( dx, al ); in( dx, ax ); in( dx, eax ); out( al, port ); out( ax, port ); out( eax, port ); out( al, dx ); out( ax, dx ); out( eax, dx );

A "port" paraméternek a 0..255 tartományba es el jel nélküli egésznek kell lennie Megjegyezzük, hogy ezek az utasítások az operációs rendszernek vannak fenntartva ha a Win32 operációs rendszer alatt dolgozunk. Emiatt bizonyos portok használata vagy a portok bizonyos körülmények között való használata jogosultsági hibát eredményezhet.

5.20

A megszakítás (int) utasítás
Eme utasítás szintaxisa "int( konstans)" ahol a konstans operandus 0..255 tartományba es el jel nélküli egész. Ez az utasítás üres sztringet ad vissza ,,returns" értékként. Lásd ,,Az assembly m vészete" (DOS verzió) hatodik fejezetét az utasítás további tárgyalásáért. Megjegyezzük azonban, hogy Win32 alatt általában nem csinálunk OS vagy BIOS hívásokat. Az "int $80" paranccsal lehet Linux alatt nagyon alacsony szint hívásokat csinálni.

5.21

A bound utasítás
Az utasításnak a következ formái lehetnek:

Randall Hyde dokumentumának magyarítása

Page 25

HLA Documentation
bound ( Reg16, mem ); bound ( Reg16, AnonMem ); bound ( Reg32, mem ); bound ( Reg32, AnonMem );

A kiterjesztett szintaxisú forma:
bound( Reg16, constL, constH ); bound( Reg32, ConstL, ConstH );

(C o ns t L )

A kiterjesztett szintaxisú forma két állandót tesz a statikus adatszegmensbe és az els konstans címével helyettesíti a memória operandust.

5.22

Az enter utasítás
Az ENTER utasítás szintaxisa: "enter( const, const );". Az els konstans operandus az eljárás lokális változói összes bájtjának száma, a második operandus pedig az eljárás lex szintje. Általános szabály, hogy ha lehet ne használja ezt az utasítást (meg az ennek megfelel LEAVE utasítást). A HLA eljárásai automatikusan létrehozzák a display és aktivációs rekordot (hatékonyabban, mintha az ENTER-t használná). Lásd a HLA kézikönyvet további részletekért az eljárás aktivációs rekordjainak felépítésér l.

5.23 A CMPXCHG utasítás
Ez az utasítás a következ szintaxist használja: Alap forma:

cmpxchg( reg/mem, reg );

Speciális forma:
cmpxchg( cmpxchg( cmpxchg( cmpxchg( cmpxchg( cmpxchg( cmpxchg( cmpxchg( cmpxchg( Reg8, Reg8 ); Reg8, Memory ); Reg8, AnonMem ); Reg16, Reg16, Reg16, Reg32, Reg32, Reg32, Reg16 ); Memory ); AnonMem); Reg32 ); Memory ); AnonMem);

Megjegyzés: a HLA jelenleg nem támogatja a Pentium cmpxchg8b utasítását, bár egyszer en létre lehet hozni egy ezt az utasítást implementáló makrót. Az #ASM..#ENDASM vagy #EMIT utasítást is használhatja a CMPXCHG8B utasítás implementálására.

Page 26

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv

5.24

Az XADD utasítás
Az XADD utasítás a következ szintaxist használja: Alap forma:
xadd( forrás, cél );

Speciális forma:
xadd( Reg8, Reg8 ); xadd( mem, Reg8 ); xadd( AnonMem, Reg8 ); xadd( Reg16, Reg16 ); xadd( mem, Reg16 ); xadd( AnonMem, Reg16 ); xadd( Reg32, Reg32 ); xadd( mem, Reg32 ); xadd( AnonMem, Reg32 );

5.25

A BSF és BSR utasítások
Ezek a bitpásztázó utasítások a következ szintaxist használják (helyettesítse BSR-t BSF-fel, ha szükséges): Alap forma:
bsr( forrás, cél );

A megengedett speciális formák:
Bsf ( Reg16, Reg16 ); bsf ( mem, Reg16 ); bsf ( AnonMem, Reg16 ); bsf ( Reg32, Reg32 ); bsf ( mem, Reg32 ); bsf ( AnonMem, Reg32 );

5.26 A BSWAP utasítás
Ez az utasítás "bswap( reg32 )" formájú. A megadott 32-bites regiszter tartalmát alakítja át a ,,little endian" és a ,,big endian" adatformátumok között.

Randall Hyde dokumentumának magyarítása

Page 27

5.27

,,Bit Test"utasítások
Ez az utasításcsoport a BT, BTC, BTR, és BTS utasításokból áll. Ezek a következ alap formában fordulhatnak el : Alap forma:
bt ( Bitszám, cél );

Speciális forma:
bt( const, Reg16 ); bt( const, Reg32 ); bt( const, mem ); bt( Reg16, Reg16 ); bt( Reg16, mem ); bt ( Reg16, AnonMem ); bt( Reg32, Reg32 ); bt( Reg32, mem ); bt ( Reg32, AnonMem );

Helyettesítsük a BTC, BTR, vagy BTS mnemonikok valamelyikét a BT helyére a fenti példákban.

5.28

Lebeg pontos utasítások

A HLA a következ FPU utasításokat támogatja.
fld( Fpreg ); fst ( Fpreg ); fld( Fpmem ); fst( Fpmem ); fstp( Fpmem ); fxch( Fpreg ); fild( Fpmem ) ; fist( Fpmem ); fistp( Fpmem ); fbld( Fpmem ); fbstp ( Fpmem ); fadd( ); fadd(Fpreg, st0); fadd(st0, Fpreg); fadd(Fpmem); fadd(Fpconst); faddp( ); faddp( st0, Fpreg ); // Returns operand. // 32 and 64-bits only! Returns operand. // Returns operand. // Returns operand. // Returns operand. // Returns operand. // 32 and 64-bits only! Returns operand. // Returns operand.

// Returns operand. // Returns operand.

Randall Hyde dokumentumának magyarítása

Page 28

HLA Language Reference

fmul( ); fmul ( Fpreg, st0 ); fmul( st0, Fpreg ); fmul ( Fpmem ); fmul ( Fpconst ); fmulp( ); fmulp( st0, Fpreg ); fsub( fsub( fsub( fsub( Fsub(

// Returns operand. // Returns operand.

); Fpreg, st0 ); st0, Fpreg ); Fpmem ); // Returns operand. Fpconst ); // Returns operand.

Fsubp( ); fsubp( st0, Fpreg ); fsubr( fsubr( fsubr( fsubr( fsubr( ); Fpreg, st0 ); st0, Fpreg ); Fpmem ); Fpconst );

// Returns operand. // Returns operand.

fsubrp( ); fsubrp( st0, Fpreg ); fdiv( fdiv( fdiv( fdiv( fdiv( ); Fpreg, st0 ); st0, Fpreg ); Fpmem ); Fpconst );

// Returns operand. // Returns operand.

fdivp( ); fdivp( st0, Fpreg ); Fdivr( ); fdivr( Fpreg, st0 ); fdivr( st0, Fpreg ); fdivr ( Fpmem ); Fdivr( Fpconst ); Fdivrp( ); fdivrp( st0, Fpreg ); fiadd( mem16 ); Fiadd( mem32 ); Fiadd( const ); Fimul ( mem16 ); Fimul ( mem32 ); Fimul ( const ); Fidiv( Fidiv( Fidiv( Fidiv( mem16 mem32 mem32 const ); ); ); ); // Returns operand. // Returns operand. // Returns operand. // Returns operand. // Returns operand. // Returns operand. // // // // Returns Returns Returns Returns operand. operand. operand. operand.

// Returns operand. // Returns operand.

Fidivr( mem16 ); Fidivr( mem32 ); Fidivr( const );

// Returns operand. // Returns operand. // Returns operand.

Randall Hyde dokumentumának magyarítása

Page 29

Fcom( ); fcom( Fpreg ); fccom( Fpmem ); Fcomp( ); fcomp ( Fpreg ); fcomp ( Fpmem ); Fucom( ); fucom( Fpreg ); fucomp( ); fucomp ( Fpreg ); fcompp(); fucompp();

// Returns operand.

// Returns operand.

ficom( mem16 ); ficom( mem32 ); ficom( const ); ficomp( mem16 ); ficomp( mem32 ); ficomp( const ); fsqrt(); fscale(); fprem(); fprem1(); frndint(); fxtract(); fabs(); fchs(); ftst(); fxam(); fldz(); fld1(); fldpi(); fldl2t(); fldl2e(); fldlg2(); fldln2(); f2xm1(); fsin(); fcos(); fsincos(); fptan(); fpatan(); fyl2x(); fyl2xp1();

// Returns operand. // Returns operand. // Returns operand. // Returns operand. // Returns operand. // Returns operand. // The following all return "st0"

finit(); fwait(); fclex(); fincstp(); fdecstp(); fnop(); ffree( Fpreg );

// Returns ""

Randall Hyde dokumentumának magyarítása

Page 30

HLA zsebkönyv
fldcw( mem ); fstcw( mem ); fstsw( mem );

Lásd ,,Az assembly programozás m vészete" megfelel fejezetét ezen utasítások leírásáért. Megjegyezzük, hogy a HLA nem támogatja a teljes FPU utasításkészletet. Ha valóban szüksége van a kimaradt néhány utasításra, használja az #ASM..#ENDASM vagy #EMIT direktívákat az utasítások kiadására.

5.29

További lebeg pontos utasítások a Pentium Pro és kés bbi processzorokban
Az FCMOVcc utasítások (cc= a, ae, b, be, na, nae, nb, nbe, e, ne, u, nu) a következ alap szintaxist használják:
FCMOVcc( stn, st0); // n=0..7

Ezek a meghatározott lebeg pontos regisztert ST0-ba mozgatják, ha a megadott feltétel teljesül. Az FCOMI és FCOMIP utasítások a következ szintaxist használják:
fcomi( st0, stn ); fcomip( st0, stn );

Ezek az utasítások úgy viselkednek, mint (a szintaktikusan egyenérték ) FCOM és FCOMP; kivéve, hogy az állapotot közvetlenül az EFLAG regiszterbe mentik el, nem pedig a lebeg pontos állapotregiszterbe.

5.30

Az MMX utasítások
A HLA támogatja a következ MMX utasításokat, amelyek a Pentiumban és a kés bbi processzorokban elérhet k (megjegyezzük, hogy bizonyos utasítások csak a Pentium III és kés bbi processzorokon elérhet k; lásd az Intel kézikönyveit a részletekért): A HLA az mm0, mm1, ..., mm7 szimbólumokkal jelöli az MMX regiszterkészletét. A következ MMX utasítások ugyanazt a szintaxist követik, amely
mmxInstr( mmxReg, mmxReg ); mmxInstr( mem64, mmxReg );

mmxInstrs:
paddb; paddw; paddd; paddsb; paddsw; paddusb; paddusw; psubb; psubw; psubd; psubsb; psubsw; psubusb; psubusw;

Randall Hyde dokumentumának magyarítása

Page 31

HLA Documentation
pmulhuw; pmulhw; pmullw; pmaddwd; pavgb; pavgw; pcmpeqb; pcmpeqw; pcmpeqd; pcmpgtb; pcmpgtw; pcmpgtd; packsswb; packuswb; packssdw; punpcklbw; punpcklwd; punpckldq; punpckhbw; punpckhwd; punpckhdq; pand; pandn; por; pxor; psllw; pslld; psllq; psrlw; psrld; psrlq; psraw; psrad;

pmaxsw; pmaxub; pminsw; pminub; psadbw;

A következ MMX utasítások különleges szintaxist követelnek meg, ami az egyes utasításokra a következ :
pextrw( constant, mmxReg, Reg32 ); pinsrw( constant, Reg32, mmxReg ); pmovmskb ( mmxReg, Reg32 ); pshufw( constant, mmxReg, mmxReg ); pshufw( constant, mem64, mmxReg ); movd movd movq movq ( ( ( ( mem32, mmxReg ); mmxReg, mem32 ); mem64, mmxReg ); mmxReg, mem64 );

Page 32

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv
emms ();

Lásd a megfelel Intel dokumentációt vagy ,,Az assembly programozás m vészete" könyvet ezen utasítások viselkedésének leírásáért.

6

A HLA memóricímzési módjai
A HLA az Intel 80x86 utasításkészletének valamennyi 32-bites címzési módját támogatja2. A 80x86 memóriacíme három lehetséges összetev b l állhat: egy eltolásból (amit offsetnek is neveznek), egy alap mutatóból és egy skálázott indexb l. A fentiekb l a következ kombinációk lehetségesek:
Displacement basePointer displacement + basePointer displacement + scaledIndex basePointer + scaledIndex displacement + basePointer + scaledIndex

Megjegyezzük, hogy a skálázott index érték nem létezhet önmagában. A memória címzési módok szintaxisa a HLA-ban a következ formák valamelyike lehet:
staticVarName

staticVarName [ constant ] staticVarName[ staticVarName[ breg32 ireg32 ] ]

staticVarName[ ireg32*index ]

staticVarName[

breg32

+

ireg32

]

staticVarName[ breg32 + ireg32*index ] staticVarName[ breg32 + constant ] staticVarName[ ireg32 + constant ] staticVarName[ ireg32*index + constant ] staticVarName[ staticVarName[ staticVarName[ staticVarName[ staticVarName[ staticVarName[ staticVarName[ breg32 + ireg32 + constant ] breg32 + ireg32*index + constant ] breg32 - constant ] ireg32 - constant ] ireg32*index - constant ] breg32 + ireg32 - constant ] breg32 + ireg32*index - constant ]

[ breg32 ]

2. Nem támogatja a 16-bites címzési módokat, mivel azok nem igazán használhatók Win32 alatt.

Randall Hyde dokumentumának magyarítása

Page 33

HLA Documentation

[ breg32 + ireg32 ] [ breg32 + ireg32*index ] [ breg32 + constant ] [ breg32 + ireg32 + constant ] [ breg32 + ireg32*index + constant ] [ breg32 - constant ] [ breg32 + ireg32 - constant ] [ breg32 + ireg32*index - constant ] "staticVarName" "basereg" "breg 32"

pillanatnyilag elérhet (lokális vagy globális) statikus változót jelöl

egy általános 32-bites regisztert jelöl.

egy alap regisztert jelöl ami bármelyik általános 32-bites regiszter lehet.

"ireg 32" egy index regisztert jelöl és lehet bármelyik általános célú regiszter, akár a címkifejezésben szerepl alap regiszter is. "index" az "1", "2", "4", vagy "8" lehetséges konstansok valamelyikét jelöli. Azokban a kifejezésekben, amelyekben az index regiszter index konstans nélkül szerepel, "*1" az alapértelmezett index.

Azokat a memóriacímzési módokat, amelyekben nem szerepel egy azt megel z változónév, ,,névtelen memóriahelynek" nevezzük. A névtelen memóriahelyeknek nincs típusa és sok esetben a HLA típuskényszerít operátorát kell alkalmaznunk, hogy a HLA elfogadja a kifejezést. Azok a memóriacímzési módok, amelyekhez tartozik egy változónév, öröklik a változó típusát. Olvassa el a következ szakaszt a HLA adattípusairól. A HLA egy másik módot is lehet vé tesz arra, hogy a különféle címzési mód komponenseket egy címkifejezésben használjuk ­ a komponeseket külön négyszög zárójelekbe tehetjük és ezeket egymás mellé írhatjuk. A következ példák a standard és a másik lehetséges szintaxist mutatják:
[ebx+2] [ebx+ecx*4+8] lbl[ebp-2] [ebx] [2] [ebx] [ecx] [8] lbl[ebp] [-2]

A kitejesztett szintaxis használatának az oka, hogy ezen a címzési módok darabkáit makrón belül is lehet használni és sokkal könnyebb a már zárójelek közé zárt két operandust egymással összekombinálni mint ezeket a standard címkifejezésben használni.

7

Típuskényszerítés a HLA-ban
Bár egy assembly nyelv soha nem lehet egy valóban er sen típusellen rz nyelv, a HLA a többi assembly nyelvnél sokkal szigorúbban ellen rzi a típusokat. A szigorú típusellen rzés egy assembly nyelvben igen zavaró lehet. Ezért a HLA bizonyos feltevéseket használ, hogy megel zze a típusellen rzési rendszer és a tipikus assembly nyelv programozó konfliktusát. Egy 80x86 gépi utasításban az egyetlen tényleges típusellen rzés annak a megkövetelése, hogy az operandusok mérete megfelel legyen. Annak ellenére, hogy a HLA gyorsan és lazán bánik a gépi utasításokkal, sok esetben típuskényszerítést kell alkalmazni az operátorokra. A HLA a következ szintaxist használja a memóriahely vagy regiszter operandus típusának kényszerítésére:
(type typeID memOrRegOperand)

Page 34

Version: 5/7/02

Written by Randall Hyde

HLA zsebkönyv Két olyan eset van, amikor a típuskényszerítés különösen fontos: (1) amikor egy olyan típust akarunk hozzárendelni egy regiszterhez, amely nem bájt, szó vagy dupla szó3; (2) amikor egy névtelen memóriához kell típust rendelni.

3. Valószín leg a legtipikusabb egy regisztert el jeles számként használni a HLA magas szint nyelv utasításaiban. Lásd a HLA magas szint utasításait a részletekért.

Randall Hyde dokumentumának magyarítása



Hasonló témájú dokumentumok

Hozzászólások

03.04/1 2004 7. gyakorlat alkotmány articulation bakteriólógia baudelaire beszerzés éghajlattan elte épszerk 3 eredménykimutatás etnicitás filozófia filozófiatörténet földrajz gábor gazd.töri tétel6 gazdasági magánjog gyakorlatok hő-és áramlástechnikai gépek ipar kérdések és válaszok kidolgozott kérdések kivágó lyukasztó szerszám tervezése konzultáció kórtan levelező magatartás magyar barok magyar gótika médiakutatás mit tudtak a régiek nemzetközi gazdaságtan pár apróság pszichó sql sűrűség számítás szintay szociológia tétel tektonika természetvédelem topográfia választások valós érték vér vízlágyítás word zsidó