( TCH | 2021. 06. 26., szo – 00:29 )

a RET utasítás tulajdonképpen egy JMP MEM[00], rövidebben JMP 00; Ami arra a címre ugrik, amit a MEM[00]-án talál.

Egy byte-os stack? Akkor az egyszintű meghívásokat is fog jelenteni, azaz, ha egy JMP (ha jól értem, ez valójában JSR?) után jön egy másik, akkor az felül fogja írni az előző letárolt címet és mind a két RET ugyanoda fog visszatérni: a második JMP mögé és egy gyönyörű végtelen "ciklust" fogsz kapni.

Pl.:

egyik:	valamit
	csinal
	itt
	ez
	JMP masik
	az
	ize
	RET

masik:	ez
	is
	csinal
	valamit
	mittudomen
	RET



main:	kod
	meg
	meg
	tobb
	kod
	JMP egyik
	meg
	meg
	egy
	kis
	kod
	stb

Itt a main-en belül meghívódik az egyik szubrutin, ekkor a nullás címre kiíródik a meghívás után következő utasítás (itt: "meg") címe, majd már a szubrutinban meghívódik a masik szubrutin és ekkor a nullás címen az előző visszatérési érték felülíródik az itteni meghívás utáni utasítás (itt: "az") címével. Ezután a masik szubrutin lefut, a végén RET kiolvassa a nullás címről az utoljára tárolt címet és folytatja az egyik szubrutinban a JMP után, viszont, amikor eléri ennek a szubrutinnak a végét, akkor a RET ugyanazt a címet fogja még egyszer kiolvasni és nem a main-ba ugrik vissza, hanem még egyszer az egyik szubrutinba, a JMP mögé...és aztán megint és megint és megint; az "az" és "ize" utasításokat fogja ismételgetni a világ végéig, vagy a resetig. Hogy fogsz így egy szintnél mélyebb szubrutinhívásokat csinálni? Szükséged lenne egy veremregiszterre, amit a JMP és a JZR mindig léptet, az mindegy, milyen irányba és az is mindegy, hogy kiírás előtt, vagy után, de mindig pont fordítva, mint ahogy a RET csinálja. Tehát, ha a JMP azt csinálja, hogy

MEM[SP++] = IP;
IP = ADDRESS;

akkor a RET-nek azt kellene, hogy

IP = MEM[--SP];

És akkor ez nem lesz gond.