Hirdetés
- Nem teljesít túl jól a kasszáknál az aktuális Xbox generáció
- AMD K6-III, és minden ami RETRO - Oldschool tuning
- Milyen notebookot vegyek?
- A GameMax háza egyedi csavarral lovagolja meg a mai trendeket
- AMD Ryzen 9 / 7 / 5 7***(X) "Zen 4" (AM5)
- Hogy is néznek ki a gépeink?
- ASUS ROG Ally
- Akciókamerák
- Xiaomi Pad 6 - kiapadhatatlan jóság
- Milyen TV-t vegyek?
Hirdetés
-
Kidobja a Slacket a Disney
it Miután több mint 1 TB céges adatot szivárogtattak ki egy hackertámadás után, a Disney úgy döntött, hogy beszünteti a Slack használatát.
-
Kiderült, mekkora aksi van az iPhone 16-okban
ma Mindegyik telep nőtt, legtöbbet az iPhone 16 Pro hízott.
-
Végre a Logitech is bemutatott egy analóg klaviatúrát
ph A dolog már eléggé időszerű volt, mindenesetre a három színben készülő, TKL-es megoldás nem dúskál a hobbistáktól ellesett okosságokban.
Új hozzászólás Aktív témák
-
rebel56
tag
Köszönöm a válaszokat!
Végül kiderült mi az a label byte: a .data részben definiáltuk:
vege LABEL BYTE db 13,10,'$'
Majd egy cnts nevű integer->string konvertáló szubrutinhoz kellett, a konvertálandó terület végét jelezte és ''vege-1''-ként hivatkoztunk rá.. vagy valami ilyesmi.
Ha be akarok kérni egy kétjegyű számot, azt úgy tudom megoldani, hogy az 1-es szolgáltatással bekérek két karaktert és az elsőt tízzel szorzom, majd hozzáadom a másodikat és eltárolom egy dw változóban? Vagy van egyszerűbb módja is ennek? -
rebel56
tag
(up)
-
kisfurko
senior tag
Beolvasod a string-et, majd végigmész rajta úgy, hogy egy változóban (regiszter) gyűjtöd az értéket. Amikor egyet lépsz előre, akkor a változódat szorzod tízzel, majd hozzáadod a következő számot. Közben igény szerint hibadetekciót is csinálhatsz (túlcsordulás, hibás karakterek).
Példa:
ds:esi mutat a beolvasott string-re
ebx-be kerül a szám
xor ebx, ebx
xor eax, eax
loop:
lea ebx, [ebx * 4, ebx] ; ez itt ottel szoroz
shl ebx, 1 ; ez meg kettovel
add ebx, eax
; ide johet a tulcsordulas ellenorzes
lodsb
; ide johet valami hibaellenorzes (ervenytelen karakter-e stb.)
cmp al, 0
jnz loop
A nyomi 8086-oshoz most nincs kedvem kódot írni -
wgaborw
tag
Sziasztok, egy kis segítségre lenne szükségem. Ebben a félévben keztünk el tanulni Assemblyt, és van egy feladaz amin vem vágunk.
Ha meg van adva egy fizikai cím (pl.: a dolgozatban 23C06h), akkor abból hogy a fenébe tudok segmens és offszet címet varázsolni, ha csak a fizikai cím van megadva.
A teljes feladat: Ítjon olyan programrészletet, amely a 23C06h című memóriaszó értékét kiírja a képernyőre decimálisan!. A feladatot memóriaváltozó nélkül oldja meg, átmeneti tárolásra használja a stack szegmenst.
Tehát hogy a fenébe érem el a fennt megadott memóriaterületet?
Előre is köszi, wgabor. -
Jester01
veterán
Ha valós módú progiról van szó (és az emlékezetem nem csal) akkor a fizikai cím = szegmens * 16 + offset. Ez alapján jó sok címet gyárthatsz hozzá, de pl. a 23C0:0006 elvileg jó.
Mellesleg érdekelne, hogy a feladat készítője szerint a stack az nem a memóriában van?Jester
-
AlbinoBatman
csendes tag
Sziasztok!
Egy kérésem lenne ti vagytok az utolsó lehetőségem.
Gondolom nem nehéz egy ilyen programot megírni, de sajna nemtom, kaptam egy utasításkészletet Z80-hoz és ez alapján kéne nekem írni egy programot írni,
az akkumulátor tartalmát 6-szorosára növelni, az eredmény az akkumulátorban keletkezzen és ha túlcsordulás van azt jelezze a flag-regiszter.
Ha egyáltalán lehetséges ilyet csinálni nagyon megköszönném, ha valaki leírná. -
Forest_roby
őstag
Hi!
Nem igazán tudom, hogy hogyan néz ki egy tömb assembly -be. Ebben kellene segítség.
Az si rámutat egy elegendően nagy memóraterületre, feltételezem a tömb első elemére és ezt a tömböt kellene feltölteni 2 -től pl 10000 -ig ( 2 byte os számokkal ). Nem tudom megcsinálni, mert ló****-t se tudok a tömbök kezeléséről assembliben.
Ha pl incrementálom si -t akkor a tömb következő ellemére fog mutatni?
Na mindegy, vki tudna ebben segíteni, rövid leítást, hogy mit hogyan kell a tömbökkel kapcsilatban....?
Előre is köszi!-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
Lortech
addikt
válasz Forest_roby #108 üzenetére
Tömb hagyományos értelemben nincs.
Neked kell megcsinálni, nem úgy van, hogy deklarálsz egyet és már használhatod is.
/si nem területre mutat, hanem egy darab címre./
Pl beleraksz si-be egy címet, aztán mov[si], ax, ekkor beraktál az si által mutatott címre 2 bájt valamit. Aztán lépteted kettővel si-t, ha két bájtokat kell tárolni, és mehet a következő mov[si], ax. Nyilván ciklusba kell szervezni, és elő kell állítani a tartalmat amit le akarsz tárolni.
Vannak tömb és string kezelést segítő utasítások, ha ennél komolyabb tömbös feladatot kapsz, ajánlom ismerkedj meg velük: rep-pel kombinálva pl lods, stos, movs, scas..Thank you to god for making me an atheist
-
Forest_roby
őstag
megnéznéd ezt?
mov bx,2
push si //vhogy el akarom tárolni az si-t!
feltolt:
mov [si],bx
add si,2 //hups
inc bx
cmp bx,4000h
jb feltolt
rafuto:
pop si //eredeti si visszanyerése vhogy!
Ez kb működhet?
[Szerkesztve]-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
Lortech
addikt
válasz Forest_roby #110 üzenetére
Ha azt szeretnéd, hogy legyen a memóriádban si-től kezdődően 16382 db wordöd, ami rendre 2,3,4...16383-et reprezentál, akkor kb működhet igen.
De miért nem próbálod ki, amit csinálsz?Thank you to god for making me an atheist
-
Forest_roby
őstag
igen, kb ezt akarom elérni, annyit módosítottam, hogy nem verembe rakom az si-t, hanem bemásolom di-be és onnan mindig elő tudom húzni, ha kell.
miért nem próbálom ki?
mert nem tudom, hogy hogyan kell, azt még nem tanultuk!
thx-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
Lortech
addikt
válasz Forest_roby #112 üzenetére
Az szép.
si-hez:
Csinálhatsz mondjuk egy ilyet a kódrész után közvetlenül, hogy ''tomb db ?''.
Ekkor a tomb szimbolizálni fog egy címet. Nem kell si-ben őrizgetni a tömböd kezdőcímét, vagy mást.
Ezt a címet pedig si-be teheted a ''mov si, offset tomb''-bel.
[Szerkesztve]Thank you to god for making me an atheist
-
Forest_roby
őstag
ujabb:
az si-t cipelem szépen a vége felé ( 2 -ével, 3-asával ..... ), hogy tudok, úgy egy cmp-t belerekni, hogy ha a köv lépés kilépne a tömbből, akkor egyik ág..., ha nem akkor másik ág....
mov bx,[si] //bx eggyenlő lesz 2-vel
nulláz:
add si,bx
mov [si],0
cmp ???
j??? nullaz
felfuto:
...
..
.
[Szerkesztve]
[Szerkesztve]-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
Lortech
addikt
válasz Forest_roby #114 üzenetére
Nem igazán értem a kérdést, a kódot sem, és azt sem, hogy mit szeretnél.
Thank you to god for making me an atheist
-
Forest_roby
őstag
Eratostenes szitája. Ketőtöl fölfelé az összes páros szám helyére 0-át szeretnék írni, aztán 3-al, 5-el, 7-el stb eljátszani ugyan ezt és a végén csak a primek maradnak.
C-ben már régebben megírtam, de az most mit sem ér....
[Szerkesztve]-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
Jester01
veterán
válasz Forest_roby #114 üzenetére
Ha nem konstans a növekmény, akkor csakis úgy, hogy hozzáadod és megnézed nagyobb-e. MOD: mivel egy menetben konstans, ezért elõre kiszámolhatod. Tehát ha éppen 7-el növelsz, akkor (meret-7)-hez hasonlítasz, amit elõre kiszámolva elrakhatsz valahová.
Amúgy milyen környezetben tanulod az assemblyt? Ha 32 bites kódot írnál, akár linux alatt egyszerûen ki is tudnád próbálni, 16 bites intel assemblyt szerintem meg úgyse nagyon használ már senki.
[Szerkesztve]Jester
-
Forest_roby
őstag
válasz Jester01 #117 üzenetére
okay, ez rendben van, de hogy kapom meg a tömb utolsó elemét, mondjuk [di + 4000h] vagy vmi ilyemi és utánna.
cmp [di + 4000h],[si+bx]
jb .....
valami ilyemire gondoltam, csak reméltem, hogy ti írtok vmi tuti megoldást...-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
Jester01
veterán
válasz Forest_roby #118 üzenetére
Vegyük észre, hogy itt mindkét oldalból levonhatod a tömb kezdõcímét.
Tehát egyszerûen cmp bx, 4000hJester
-
Forest_roby
őstag
válasz Jester01 #119 üzenetére
az si folyamatosan kuszik felfelé a tömbön, a di meg az si kezdőértéke ezért gondoltam erre, de igazad van igy sokkal jobb.
Látszik, hogy amatör vagyok!
[Szerkesztve]-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
Jester01
veterán
-
Lortech
addikt
válasz Forest_roby #116 üzenetére
Mondjuk ezt az apróságot megemlíthetted volna, talán nem olvastam volna el a hsz-edet 10edszerre is feleslegesen.
Az a szép az assemblyben, hogy mindenki máshogy áll hozzá, mindent meg lehet oldani 100 féleképpen, és egy viszonylag egyszerű kód is totál érthetetlen lehet a cél ismerete nélkül egy nem professzionális asm programozó számára.
[Szerkesztve]Thank you to god for making me an atheist
-
P.H.
senior tag
válasz Forest_roby #116 üzenetére
Eratostenes szitája 16384 hosszú word tömb (indexek: 0..16383). Gondolom, 16 bites assemblyről van szó.
alkossuk meg 2 ciklusból:
- az elején a teljes tömböt feltöltjük 1-gyel
- a belső ciklus megkapja, hogy mennyi az aktuális prímszám, és ennek többszöröseit kinullázza (a legelső prím a 2 lesz)
- külső 2-ről indul felfelé, és ami nem lett korábban kinullázva, annak az elemnek az indexére lefuttatja a belső ciklust
a bemenet: a tömb címe (assemblyben is egy tömb egy folyamatos memóriaterület, csak itt a tömbelemek méretét kézzel kell leprogramozni)
a kimenet: a tömbben azok az elemek lesznek 1-ek, amik prímszámok
pusha // mentsünk minden register-t, az a biztos
mov si,{tömbcím} // SI lesz a bázisindex, nem fog változni
xor dx,dx // DX <- 00h konstans, így kisebb a kód
mov [si+00h],dx // 0. elem nullázása
mov [si+02h],dx // 1. elem nullázása, ezek nem prímek
mov bx,01h // BX <- 1, mint a legkisebb_prím-1
mov di,(2*4000h) // DI <- a tömb byte-mérete
@FELTOLT: //
sub di,02h // DI <- aktuális offset
js @KULSO //
mov [si+di],01h // aktuális elem legyen 1
jmp @FELTOLT //
@KULSO: //
add bx,01h // BX <- aktuális index
mov di,bx // DI <- aktuális index
cmp bx,4000h // elöltesztelős a ciklus
jae @RETURN // KILÉPÉS (ugrás a végére)
add di,di // DI <- aktuális offset (word elemek)
cmp [si+di],dx // leteszteljük, hogy az elem 0-e
jz @KULSO // ha igen, ő nem lehet prím
mov ax,di // AX <- a belső c. offset-növekménye
@BELSO: //
add di,ax // DI <- következő offset (2x, 3x, ...)
cmp di,(2*4000h-02h) // teszt az utolsó word offsetjével
ja @KULSO //
mov [si+di],dx // nullázzuk az elemet
jmp @BELSO //
@RETURN: //
popa // regiszterek visszaállítása
Pici módosítással megoldható, hogy az eljárás dinamikus legyen, azaz a tömb méretét is paraméterként megkapja (a CX register pl. üres, abban lehet tárolni futás közben)
Remélem érthető, és a kód is élvezhető megjelenésű lesz.
Talán így élvezhető. // mögött komment. Nem fordítottam, nem lehet benne nagy hiba.
[Szerkesztve]Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
P.H.
senior tag
Hopsz, egy dolgot benéztem, 16 bitben báxis-index párral lehet csak címezni, index-index-szel nem, szóval nemes egyszerűséggel a BX-et és a DI-t fel kell cserélni
..pusha
..mov si,{tömbcím}
..xor dx,dx
..mov [si+00h],dx
..mov [si+02h],dx
..mov di,01h
..mov bx,(2*4000h)
@FELTOLT:
..sub bx,02h
..js @KULSO
..mov [si+bx],01h
..jmp @FELTOLT
@KULSO:
..add di,01h
..mov bx,di
..cmp di,4000h
..jae @RETURN
..add bx,bx
..cmp [si+bx],dx
..jz @KULSO
..mov ax,bx
@BELSO:
..add bx,ax
..cmp bx,(2*4000h-02h)
..ja @KULSO
..mov [si+bx],dx
..jmp @BELSO
@RETURN:
..popa
a ..-ok az elején csak formázás miatt vannak, így áttekinthetőbbek a label-ek talán.
[Szerkesztve]Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
Forest_roby
őstag
hi!
P.H. ez nagyon rendes volt tőled, bár szerencsére csak most vettem észre, hogy megcsináltad. A cél az, hogy megtanuljak assembly nyelven programozni és nem az, hogy más munkáját lemásoljam, de tényleg rendes vagy!
én ezt dobtam össze, a vége már nagyon hanyag és rossza, de nem érdekelt, már nagyon fáradt voltam!
Feladat vmi olyasmi volt, hogy csináljunk szitát a prímek kiszámolására, al -be kapunk egy számot 1-256 között és annyiadik primet meg kell tudni mondani, amennyi az al értéke.
Az si rámutat egy megfelelően nagy mem terület elejére, a tömbnek 2 bytes-nek kell lennie és a feladat végén az si-be bele kell tölteni az első al prímet 0-ák nélkül.... ( 80x86 os proci )
házi:
kezd:
..mov bx, 2
..di,si
feltolt:
..mov [si],bx
..add si,2
..inc bx
..cmp bx,4000h
..jb feltolt
-------------------
..mov cx,[di+8000h]
..dec cx
..mov dx,cx
..shr dx,1
..mov si,di
fel:
..mov bx,[si]
..shl bx,1
ide:
..add si,bx
..mov [si],0
..cmp cx,[si]
..jnb ide
---
..mov si,di
..sub bx,4
..add si,bx
ell:
..add si,2
..cmp [si],0
..je ell
---
..cmp [si],dx
..j?? fel
---------
//ha idáig eljut, akkor megvannak a prímek
---------
..mov cx,1
..mov si,di
..cmp al,1
..je bubble_sort
_add_:
..add si,2
..inc cx
..cmp si,0
..je _add_
..dec al
..cmp al,0
..jne _add_
-----
bubble_sort: //már nincs időm, úgyhogy nem buborék
rendezést csinálok, valószínüleg nem is lesz jó.
..mov si,di-2
vvvv:
..add si,2
..dec cx
..cmp [si], 0
..je vvvv
..mov di,[si]
..add di,2
..cmp cx,0
..jne vvvv
END
A végén az si-be vissza kellett volna tölteni az első ( al értéke ) x darab prímet, de mint látható én a di-be próbáltam ezt megcselekedni rosszul....
Várok a kritikákat!
[Szerkesztve]-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
P.H.
senior tag
válasz Forest_roby #125 üzenetére
Nincs mit, azért csináltam meg, mert egyrészt ez egy kerek feladatnak látszott, és assembly-ben úgy érdemes tanulni, hogy nagyon sok példaprogramot átnézel, amellett, hogy Te is megcsinálod. (én így úgy kezdtem, hogy kaptam egy floppy-nyi kb. ilyen bonyolutságú példaprogramot, és azokat nézegettem, értelmeztem, közben csináltam az én saját kitűzött nagyobb lélegzetű célomat.), másrészt meg (ahogy Lortech is említette) jól szemlélteti, hogy érdemesebb átfogóan nézni egy algoritmust, minthogy C utasításonként megpróbálni leprogramozni.
Pont most az előbb saját szórakozásra megcsináltam egy picit optimalizáltabban is, de azt már kommentek nélkül csak én és a CPU értjük
Most éppen dolgozok, de délután lesz időm, mindenképpen átnézem a megoldásodat.Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
P.H.
senior tag
válasz Forest_roby #128 üzenetére
Végignéztem, az algoritmus jó, néhány logikai bukfenc van benne, megpróbálom felsorolni, hogy mire figyelj:
- ha DI-vel címzel, akkor figyelj, hogy a DI az ES szegmensregister-rel van alapvetően párosítva, egyáltalán nem biztos, hogy a tartalma megegyezik a DS-sel (amibe az SI címez alapból). Vagy másold át a DS tartalmát az elején az ES-be (mov ax,ds és mov es,ax), vagy minden [di...] elé tedd ki azt, hogy es:[di...].
- ha feltöltöd a tömböt, és 2-vel indítod a számlálót, akkor összesen 4000h-2 elemet töltöttél fel, az utolsó feltöltött elem offset-e 2*(4000h-3). Ha 0-ról indítod, a [di+8000h] címen akkor sem fogsz találni semmi olyat, amit te írtál oda, így meg főleg nem. Na bonyolítsd, egyszerűen írd helyette, hogy mov cx,4000h, úgyis ezt az értéket várod oda.
- teljesen igaz, hogy a külső ciklus csak a számok feléig menjen el
- mov [si],0 és cmp cx,[si]: ha először kinullázod, akkor a feltétel mindig igaz lesz, tehát már van is egy végtelen ciklusod. Vagy először vedd ki az eredeti értéket egy registerbe (ha van szabad; itt van, ha a BP-vel nem címzel, akkor nyugodtan használhatod számolásra, tárolásra), nullázd, majd a kivett értéket teszteld. Vagy írd így:
cmp cx,[si]
mov [si],0
jnb ...
Nyugodtan lehet így, az ugró utasítások csak a flag-eket figyelik (kivéve jcxz), a mov nem bántja a flag-eket.
- mov si,di, sub bx,4 és add si,bx: valahonnan onnan akartad folytatni, ahol a belső ciklus előtt abbahagytad, csakhogy számold ki, ha a fel:-nél a megfogott érték 11: bx 11*2=22 lesz, -4=18, /2=9, itt már 9 elemet ugrottál, a 13 máris kimaradt. El kell menteni a fel: után az SI értékét (mondjuk push si), és itt visszahozni (pop si), ez a biztos. (Ha viszont ilyesmi címet akarsz számítani, akkor ezt lehet írni pl. lea si,[di+bx-4] formában is, egy menetben.)
- ell: után nem ellenőrzi semmi, hogy kifutsz-e a ciklusból, (szép védelmi hiba Win alatt), csak növeled az si-t, ezt azért érdemes lenne kézben tartani
- a kérdőjeles ugrás legyen jbe, (de ha 8191 nem prím, akkor lehet jb is)
- dec al, cmp al,0 és jne _add_: semmi hibája, de egy tanács: a dec (és még jó pár utasítás) rögtön beállítja a flag-eket, a cmp felesleges utána (hacsak nem a CF-re vagy kíváncsi. Jobb helyeken pont ezért nem használjuk az inc/dec párt, mert nemhogy a CF-et nem állítja, de emiatt függ az előző utasítás eredményétől is a futása. add/sub xxx,1 a biztos ).
- mov si,di-2: ez sehogy nem illik a képbe, ilyen forma nincs is, ráadásul egy hanyagabb fordító mov si,[di-2]-nek fogja fordítani, hibaüzenet nélkül. Itt a címre vagy kíváncsi, akkor lea si,[di-2], így kellene (itt nem kell az ES: előtag).
- bubble ok, bár az _add_ alatt sem nézed, hogy kifutsz-e a tömbből.
Tipp: a label-eket nevezd el úgy, hogy utaljanak arra, hogy mi történik alattuk. Az se rossz, ha benne van a nevükben az eljárás neve, amiben vannak. Minden sor érdemes írni egy rövid kommentet, az ugró utasításoknál húzni egy vonalat a célhoz. Az én ipari kódom ilyen: [link]. Általában kézfájásig gépelek naponta (és hagyományosan angolul kommentezek, mert rövidebb, és általában a fordítók nem szeretik ott sem, ha halmozod az ékezeteket), de fél év múlva is tudom, mit akartam csináltni az egyes sorokban (a fenti beírt kódjaimban utólag kiszedtem, mert a motor nem toleráns a sok space-szel).
Remélem segítettem, és nem voltam nagyon fárasztó.
[Szerkesztve]Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
P.H.
senior tag
válasz Jester01 #130 üzenetére
Intel (és AMD is!) optimization reference-ek szerint az egyik key optimization az inc és dec utasítások elkerülése. Mivel ezek nem változtatják a CF flaget, és mivel minden flag-módosító microop teljes flag-térképet is visszaad a lefutása végén, ezért ezeknek meg kell várniuk a (programsorrendben) előttük levő flag-módosító utasítás visszavonulását (retire Intel szóhasználattal), hogy megkapják tőle a CF tartalmát, és elkezdhessenek futni. Ezért nagyon rosszul párhuzamosíthatóak.
[mod]: Tehát épp olyan függőség alakul ki köztük, mint monduk ha
mov eax,ebx
shl eax,08h
lenne a kód.
[Szerkesztve]Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
Forest_roby
őstag
Thx!
Átolvastam, de még kell egy kis idő, hogy ez elmélyüljön... : )
All!
ismeritek ezt a progit?
[link]
Ebben kell teszteknünk a progikat.
Nem tudtok vmi jobbat? (linux / windows -mindegy, bár a linuxot preferálom!)-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
P.H.
senior tag
válasz Forest_roby #132 üzenetére
Ez tényleg off, csak az agyam elindult: Nem ismerem ezt a progit. És azon nem tudok a mai napig túllépni (én is átestem rajta), hogy mindenhol a 8086 programozását oktatják, még mindig. Erőltetik, pedig ezzel lehet a legjobban elvenni az ember kedvét ettől az egésztől. 32 biten olyan gyönyörű megoldásokat lehet csinálni (és az MS-DOS is teljesen ki tudja használni, ha nincs emm386.exe, csak himem.sys), nem sokkal nagyobb kóddal, logikusabb (pl. minden regiszterrel lehet címezni, ismeri a címben a *2, *4, *8 tagokat, sokszor nem kell szenvedni a kézi offset-tel, stb), és azzal a tudással onnan sokkal könnyebb visszamenni a 16 bites dolgokra is szerintem. Ha már egyszer CISC a téma.
Ezzel szemben ebből a programból még a kicsi agyammal kilépni se tudok szabályosan, pedig csak kicsit komolyabb, mint a DOS-os debug. Ez az én hibám, nem szántam a helpre 5 másodpercet sem. De szerintem manapság több informális értéke lenne egy 32 bites inline assembly-nek, mint ennek a 16 bitesnek, amit már egy Delphi 4 se fordít, pedig nem mai darab a kicsike.
Pedig én is 16 biten kezdtem, tanulni is, meg a munkámat is, 2-3 évig abban dolgoztam. Tavaly már nem vállaltam el egy 16 bites munkát. Annyira nem fizették volna meg.
És emellett nyakunkon a 64 bit, és mindenki elrebeg egy imát, hogy a register-nyomás nevű fogalom végre megszűnik.
On: Nem ismerem. De bármely (szinte) magas szintű fordító tud inline assembly-t (Visual C nem biztos ). Én a Delphi-t (Linux alatt Kylix) ismerem/ajánlom, 32 bites assembly-t tud (MMX, SSE, SSEx verziófüggő, de az talán még nem is kell), abban normális help van a paraméterátadási konvenciókról, és ehhez a programhoz hasonló részletességű CPU-window is van benne.
[Szerkesztve]Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
P.H.
senior tag
Megint elkövettem egy szarvas hibát: amire utalni akartam az első és a kilencedik pontban, az a DS: előtag lett volna, [di...] mellett.
Ha komolyan nekiindulsz, akkor ajálnom figyelmedbe mindenképpen a 32 bites dolgokat, mindekelőtt a:
- Fókuszban a Pentium (szerző holnap, a cégnél használom, könyvesboltban kapni még talán)
- Perifériák programozása Pascal és Assembly nyelven (ha valahol... ha nem, megosztom veled, csak egy jó 486-os konfig kell hozzá, de ezen meg fogod tanulni, az biztos )
- (egy, mondjuk Intel P2/P3 optimization reference)
kötetek teljes átnézését. A velük álmodást nem
[Szerkesztve]
[Szerkesztve]Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
xuldar
őstag
Segítség kellene assemblyből. Részletek priviben, köszi.
Azért jó mazochistának lenni, mert ha rossz, akkor jó. De ha meg jó, akkor rossz, tehát jó.
-
Polacsko
tag
helló mindenkinek!
tudna vki segíte ebbe a 3 feladatba?nagyon hálás lennék!
1. Készíts programot, ami az adatszegmensébe írt mondatról eldönti, hogy palindrom-e!(visszafelé olvasva is megegyezõ mondat, pl: ''indul a görög aludni'') A szóközök esetleges különbözõ helyét hagyja figyelmen kívül! Az eredményt (igen/nem) írja ki a képernyõre!
2. Készíts egyszerû rajzolóprogramot a 320x200-as grafikus üzemmódban, ami billentyûzetrõl vezérelhetõ. Funkciók: pozicionálás, rajzolás ki/be, színezés. Kilépés Esc-re!
3. Készíts programot, ami a 80x25-ös karakteres képernyõ tartalmát elmenti fájlba!
minden féle segítséget várok!előre is köszi! -
Polacsko
tag
vki?
pls -
P.H.
senior tag
válasz Polacsko #137 üzenetére
Láttam a kérésed, ha egy kis idő van rá, segítek, talán holnap este lesz rá időm. Csak előtte pár dolgot fel kell frissíteni a fejemben ezekhez.
Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
Polacsko
tag
pls
-
-
fler
tag
Sziasztok!
Kellene egy kis segítség pár assembly kódban.
1.
procedure Fgv21(VAL a:dword; VAL b:dword);
@nodisplay;
begin Fgv21;
x=(b#13_8 : a#10_9 : a#(b#N_0)_3 : b#3_5)#+32
y=(a#23_15 : b#17_5 : a#2_10)#-32
Fgv21=(x^y)-(b#3_11 : (a#28_12)#T)#+32
end Fgv21;
Ennél az a problémám, hogy nem tudom mit jelent pl: b#13_8. Ha tudja valaki, ezeket hogy kell kezelni, sztem már menni fog.
2.
Egy eljárás írása:
Procedure Fgv31 (VAR V1:int64; VAL V2:int64; RESULT R:int64);
Begin Fgv31; //R=V1+V2
end Fgv31;
Ezzel az a gondom, hogy hogy kezeljem az int64-et. Gondolom át kell alakítanom int32-vé, hogy tudjam regiszterekkel kezelni.
Ja és HLA val fordítom.
Ha tud valaki segítsen, péntekig mindenképpen kéne.
Köszönöm. -
P.H.
senior tag
A második kérdés megoldása lehet: [link]
''Ennél az a problémám, hogy nem tudom mit jelent pl: b#13_8. Ha tudja valaki, ezeket hogy kell kezelni, sztem már menni fog.'' Meg az is, hogy ha senki nem tudja, akkor nem lesz válasz. Szvsz Te tudsz legkönnyebben utánakérdezni. És az ''N_0'', a ''T'', a ''#+'', a : és a ^ operátorok jelentésének is.
Ha ezeket megmondod, akkor lehet (csak) esély egy holnapi megoldásra...
[Szerkesztve]Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
P.H.
senior tag
Egy 16 bites optimalizálási agymenés, a fent említett, 320x200-as rajzolási feladatra.
KOD SEGMENT PARA PUBLIC 'CODE'
.assume CS:KOD, DS:ADAT, SS:VEREM, ES:NOTHING
.MAIN PROC FAR
..........mov ax,ADAT
..........xor dx,dx
..........push ds
..........mov bx,0A000h
..........mov ds,ax
..........mov cx,0FF20h
..........mov bp,100
..........mov es,bx
..........push dx
..........mov ax,0013h
..........mov si,160
..........int 10h
...@mode:.xor ch,0FFh
...@chgX:.adc si,dx
...@draw:.test ch,ch
..........mov bh,cl
..........jz @curs
..........mov di,si
..........call PIXELBP
...@curs:.call CURSORON
...@key:..xor ah,ah
..........int 16h
..........add al,al
..........mov bl,al
..........js @key
..........jc @key
..........call CURSOROFF
..........xor bh,bh
..........jmp word ptr ds:[REDIR+bx]
...@clr:..inc cl
..........jmp @draw
...@left:.sub si,01h
..........jmp @chgX
...@rght:.cmp si,0319
..........jmp @chgX
...@up:...sub bp,01h
..........adc bp,dx
..........jmp @draw
...@down:.cmp bp,0199
..........adc bp,dx
..........jmp @draw
...@exit:.mov ax,0003h
..........int 10h
..........ret
.MAIN ENDP
.CURSORON PROC
.; ES -> display segment
.; DX: $00 value
.; SI: current x coordinate
.; BP: current y coordinate
.; BH: draw color
.; DX,CX,BX,BP,SI unchanged
..........lea ax,[bp-01h]
..........call PIXELSI
..........mov SAVE+00h,al
..........lea ax,[bp+01h]
..........call PIXELSI
..........mov SAVE+01h,al
..........lea di,[si-01h]
..........call PIXELBP
..........mov SAVE+02h,al
..........lea di,[si+01h]
..........call PIXELBP
..........mov SAVE+03h,al
..........ret
.CURSORON ENDP
.CURSOROFF PROC
.; ES -> display segment
.; DX: $00 value
.; SI: current x coordinate
.; BP: current y coordinate
.; DX,CX,BL,BP,SI unchanged
..........lea di,[si+01h]
..........mov bh,SAVE+03h
..........call PIXELBP
..........lea di,[si-01h]
..........mov bh,SAVE+02h
..........call PIXELBP
..........lea ax,[bp+01h]
..........mov bh,SAVE+01h
..........call PIXELSI
..........lea ax,[bp-01h]
..........mov bh,SAVE+00h
.CURSOROFF ENDP
.PIXELSI PROC
..........mov di,si
..........jmp PIXEL
.PIXELSI ENDP
.PIXELBP PROC
..........mov ax,bp
.PIXELBP ENDP
.PIXEL PROC
.; return value (AL): previous color
.; (AL undefined at invalid x or y)
.; return value (DX): $00 value
.; return value (BH): new color
.; ES: display segment
.; AX: y coordinate
.; DI: x coordinate
.; BH: new color
.; CX,BX,BP,SI unchanged
..........cmp di,0320
..........jae @end
..........cmp ax,0200
..........jae @end
..........mov dx,0320
..........mul dx
..........add di,ax
..........mov al,es:[di]
..........mov es:[di],bh
....@end:.ret
..PIXEL ENDP
KOD ENDS
;--------------------------------------------------------
ADAT SEGMENT PARA PUBLIC 'DATA'
.SAVE DB 4 DUP(?)
.REDIR DW @draw,@draw,@draw,@draw,@draw,@draw,@draw,@draw,
..........@draw,@draw,@draw,@draw,@draw,@mode,@draw,@draw,
..........@draw,@draw,@draw,@draw,@draw,@draw,@draw,@draw,
..........@draw,@draw,@draw,@exit,@draw,@draw,@draw,@draw,
..........@clr, @draw,@draw,@draw,@draw,@draw,@draw,@draw,
..........@draw,@draw,@draw,@draw,@draw,@draw,@draw,@draw,
..........@draw,@draw,@down,@draw,@left,@draw,@rght,@draw,
..........@up , @draw,@draw,@draw,@draw,@draw,@draw,@draw
ADAT ENDS
;--------------------------------------------------------
VEREM SEGMENT PARA 'STACK'
.DW 100 DUP (?)
VEREM ENDS
;--------------------------------------------------------
END MAIN
; permanent data:
.; DS -> ADAT segment
.; ES -> display segment
.; DX: $00 (cleared at startup, PIXEL multiply clears)
.; SI: current x coordinate
.; BP: current y coordinate
.; CL: current draw color
.; CH: draw state (00:off 0FFh:on)
[Szerkesztve]Arguing on the Internet is like running in the Special Olympics. Even if you win, you are still ... ˙˙˙ Real Eyes Realize Real Lies ˙˙˙
-
Forest_roby
őstag
Hi!
Nemsokára itt az assembly vizsgám és a gyak jegyet is ott kell megszereznem . úgy hogy viszek egy 40-50 soros ( gyakorlatban nem feltétlenűl működő ) programot, ami vmi logikai dolgot végez hatékonyan. pl.: buborékrendezés, prím szám keresés, prímtényezős felbontás, legnagyobb közös osztó, stb....
csak maga az algoritmus kell, ami elvégzi ezt a feladatot - maga a dolgot ( számokat ) amivel dolgoznia kell azt úgy kapja meg híváskor...
Az is lényeges, hogy egyes buktatókra nézve - többféleképpen meglegyen a program ( pl.: helyben számolás v. külön memóriahelyen számolás.... )
Tudna vki ebben nekem segíteni? Nagyon konkrétan - ha van vmi ilyen jellegű programotok, azt megosztanátok velem vagy álljak neki és ha elakadok, akkor jöjjek vissza?
8086 -os kompatibilis progi kellene
Előre is köszi!
Forest-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
Forest_roby
őstag
válasz Forest_roby #147 üzenetére
up!
-=Legyél Laza!=- __ ''Have you tried turning it off and on again?'' __ ''Is it definitely plugged in?'' /o\ :D:D
-
MUŁĐER
addikt
Hi
Lenne pár kérdésem egy asm progival kapcsolatban.
[link]elsőnek pl.:
BEOLVAS:
int 21h
mov string[si],al
inc si
cmp al,13
loopne BEOLVASdec si
mov [hossz],si
résznél miért csökkenti az si-t?Robotika törvényei: 3. A robot megvédi magát halálos fegyverzettel, mert egy robot rohadt drága.
Új hozzászólás Aktív témák
Hirdetés
- Playstation 3 konzolt vennék PS3
- AKCIÓ - Ducky Billentyűzet Bazár! Ducky ONE 2 SF RGB, Ducky ONE 2 MINI RGB...
- ÚJ aktiválatalan Apple iPhone 15 Plus 128GB Black ! 1ÉV APPLE GARANCiA
- ÚJ HP 15-fc0555nh - 15,6"FHD - Ryzen 5-7520U - 8GB - 512GB SSD - Win10 - 2év garancia - MAGYAR
- ÚJ aktiválatalan Apple iPhone 15 Pro Max 512GB Natural Titanium ! 1ÉV APPLE GARANCiA
Állásajánlatok
Cég: Ozeki Kft
Város: Debrecen
Cég: Ozeki Kft
Város: Debrecen