No  me  acuerdo  bien por donde iba, pero este es un momento
tan bueno como cualquier otro para hablarles del STACK.
El Stack es un lugar de la  memoria  donde  puede  guardarse
rapidamente  el contenido de un registro."Stack"quiere decir
algo asi como "pila", en el sentido de una pila de  monedas,
o  fichas.  Se  asemeja a esto porque el ultimo elemento que
se  pone es el primero que se saca. En realidad a mi siempre
me parecio mas a esos  aparatitos  para  guardar  fichas  de
subte o monedas.
los registros siempre se guardan como registros de 16 bytes,
es decir que no se puede, por ejemplo,  guardar AH y AL  por
separado,  se  guarda  AX  completo. La orden que guarda los
registros es PUSH seguido del nombre  del  registro.  Notese
que  el  comando es muy onomatopeyico, es como el sonido que
hace una persona al zambullirse en el  agua.  La  orden  que
saca  un  registro  del stack es POP, que a mi me suena como
el ruido de un corcho al salir (parece  sonso,  pero  el  la
unica  manera  de  que  me  acuerde  cual es el comando para
poner y cual el de sacar). El guardar  el  contenido  de  un
registro  no significa que se borre lo que tiene, si hacemos
un push el contenido se copia en la  parte  superior  de  la
pila  (apodada  la  CIMA  del  stack).  Vamos  a  simular un
stack:

                                             !  fondo
                                                =cima


        push AX                             AX
        push BX                           BXAX
<-0000  push CX                         CXBXAX     FFFF->
        pop  AX                           BXAX
        pop  CX                             AX

las  flechas indican para donde estan las posiciones bajas y
altas de memoria. Como ven, el fondo del stack esta  siempre
en  el  mismo  lugar, en la posicion mas alta de memoria. La
cima, que al principio coincide con el fondo  va  bajando  a
medida  que  el  stack  se  va  llenando. primero guardo AX,
despues BX, despues CX. ninguno de  los  contenidos  de  los
registros  se  pierde,  sino  que  son copiados en el stack.
Ahora saco el ultimo valor que  puse  (era  cx,  recuerdan?)
pero lo mando al registro AX: lo que habia en el registro AX
se pierde y es reemplazado por lo que estaba en la cima  del
stack. (Notese  que  hacer  push cx - pop ax es lo mismo que
hacer mov ax,cx:esto a veces es la unica  manera  de  cargar
un  registro  con  un valor dado ) ahora saco otro valor del
stack  hacia  el  registro  cx  (que  viene  a  ser  lo  que
originalmente estaba en el registro bx)

Para que sirve? :

Cuando  yo  hago  una  llamada  hacia una subrutina que va a
hacer algo con un valor que le paso en uno de los registros,
casi seguro que va a tener que usar el resto  de  los  demas
registros  para  algo, como por ejemplo pasarle parametros a
una interrupcion, entonces la mejor manera de  conservar  el
valor  que  tenian esos registros es guardarlos en el stack
antes de entrar en la subrutina y recuperarlos del mismo  al
salir de ella.

Ejemplo ( a ver si se entiende)

        call letec      ;llamo a la rutina etec
        call escri      ;llamo a la rutina escri
        int 20          ;vuelvo al DOS
letec   mov ah,00       ;interrupcion 16h funcion 00
        int 16          ;espera que apretemos una tecla y
                        ;devuelve en ah el numero de tecla
                        ;(ej: esc=01, f1=02, etc) y en AL
                        ;el codigo ASCII de la tecla
        ret             ;vuelvo del call
                        ;la siguiente rutina saca un caracter
                        ;cuyo codigo ascii esta en AL por
                        ;pantalla en la posicion del cursor
 escri  push ax         ;guardo ax
        push bx         ;guardo bx
        mov ah,0E       ;funcion 0eh
        mov bh,00       ;en bh numero de pagina (gral- 0)
        mov bl,00       ;en bl color de fondo (modo graf.)
        int 10          ;interrupcion 10
        pop bx          ;recupero bx
        pop ax          ;recupero ax
        ret             ;vuelvo de la subrutina

aca  no  luce mucho, pero lo util de esto es que independizo
las rutinas del programa en las que la estoy usando: aca  no
me  sirve de nada guardar bx y despues recuperarlo porque su
contenido no es importante. Pero si quiero usar esta  rutina
en  otro  programa  donde  el contenido de bx si importa, si
pongo todos los push y pops esta rutina se va a  poder  usar
en cualquier programa.

Tambien  les  hago notar que cuendo examinan un programa con
el sourcer y estan totalmente perdidos, una sucesion de push
indican el comienzo de una rutina y una sucesion de pops  el
final.

seguro que la pifie en algo, porque el stack es algo que uno
usa sin pensar mucho en ello. Les agradezco si me marcan los
errores.

(continuara?)

 "No tire su vieja computadora: donela al museo de computacion!"