a los amantes de la programa cion aqui les traigo un juego en el que se usa la programacion, un lenguaje similar al ensamblador pero con unas 20 instrucciones. ya el usuario elkaoD ha hecho un magnifico tutorial de introduccion pasar por su tema en core war juego de programacion.
hay muy pocos tutoriales en espagnol solo el de elkaoD yo estoy creando un libro que al momento tiene unas 40 paginas y continuo en el que muestro tambien lo basico pero con ejemplos sin entrar en el codigo del juego. es un tutorial que abarco aspectos teoricos del propio lenguaje para que ustedes primero entiendan la sintaxis de las instrucciones despues se entrara en lo que es los guerros propios del juego.
mi tutorial comienza desde los tipos de direcionamientos.
ya que elkaoD tiene toda la parte introductoria.
aqui dejo un pequegno ejemplo del libro los interesados me lo hacen saber y continuo.
APENDICE:
1-MODOS DE DIRECCIONAMIENTO.
2-USO DE LAS INSTRUCCIONES ADD,SUB,MUL,DIV,MOD
3-USO DE LAS INSTRUCCIONES JMP,JMZ,JMN,DJN
4-USO DE LAS INSTRUCCIONES CMP,SEQ,SNE,SLT
5 USO DE SPL,LDP,STP
modos de direccionamientos de memoria
aclaro muchos de los ejemplos que espongo aqui no hacen nada solo son a modo de explicaion para hacer entender algunos conceptos cuando se de el caso de un programa real o guerrero lo especifico.
#---inmediato
$----indirecto (se puede omitir)
@----indirecto del campo B
*----indirecto del campo A
{----indirecto del campo A con predecremento
}----indirecto del campo A con postincremento
< -- indirecto del campo B con predecremento
-- indirecto del campo B con postincremento
bien primero que nada vamos a lo que son conceptos.
? que es un direcionamiento?
es un movimiento de dato de un lugar a otro en la memoria, o el movimiento
de una direccion de memoria a otra (puntero)
*el lenguaje usado en en core war se llama redcode que es muy similar a
las instrupciones que tiene el lenguaje ensamblador pero mas reducido para un juego, pero potente dentro del mismo juego.
veamos como es el lenguaje ensamblador versus redcode.
en ensamblador manejamos registros y bytes pero en redcode manejamos instrupciones.
ensamblador: mov ax,5
redcode: mov #5,10 o mov #5,$10 ,mov #5,#10 etc
en ensamblador se usan los nemonicas del propio lenguaje al igual q en RC, en otras palabras instrucciones, en lenguaje ensamblador la sintaxis de una instrucion digamos aquella que tiene 3 partes
nemonicos son palabras reservadas del lenguaje o instrucciones que entienede el lenguaje. jemplo
mov,add,sub,div,etc
como:
mov ax,10
mov destino , fuente
esto es mov--- mueve lo que esta en la fuente a destino
mueve el valor inmediato 10 al registro ax, ax vale 5
cuando se ejecuta esa linea.
otro ejemplo.
mov ax,5
add ax,5-------agrega fuente a destino. agrega 5 a ax
ax=5 primera instrucion.
add ax,5 --ahora despues de ejecutar esta linea
ax=10
si muy lindo todo pero y redcode no tiene AX,bx,cx,etc registros como el
lenguaje ensamblador, pues no.
pero si tiene fuente y destino como el lenguaje ensamblador pero de un modo diverso.
?que es diverso?
bien: veamos un esquema de los dos lenguajes.
ensamblador: opcode destino, fuente
redcode: opcode fuente, destino
se dan cuenta al final es lo mismo, la fuente siempre va al destino.
Bien veamos el primer tipo de direcionamiento.
--inmediato (lo de # es un simbolo que se usa ya veran como)
definicion:Es un valor directo, o dato directo cuando digo directo
es decir inmediatamente.
veamos con ejemplo. en C++ para declarar una variamble decimos
int var=5 declaro una variable de tipo int valor 5
var=20 ahora aqui le meto inmediatamente el valor 20
ya var no vale 5 sino 20.
en ensamblador se declaran variables depende del tipo si es byte ,word etc
asi:
var db 5---esto es var es de tipo byte y vale 5 (todavia esto no es indirecto)
ahora si hacemos esto.
mov ax,var ---->direcionamiento directo. (esto no es inmediato)
aqui lo que recoje ax es el valor que contiene el offset
o direccion de memoria
para ser mas explicito.
digamos que la memoria es un gavetero del 1 al 100
el ensamblador digamos que guardo el valor de var=5
en la direccion de memoria (en la gaveta 50)
gaveta1=0 gaveta2=0 etc 0,0,0 gaveta50=5 etc 0,0, 100=0
cuando se dice mov ax,var el ensamblador va a la posicion 50 y recoje el 5
que esta en esa gaveta(direccion de memoria)
es decir apunta a la direcion de memoria es como si dijera
mov ax(dame),lo que esta en gaveta(50)
Direccionamiento inmediato
mov ax,25----> esto si que es direccionamiento inmediato. el valor 25 va inmediatamente depositada al registro ax
ven la diferencia de una y otra:
veamos la de cerca.
dato db 15---->digamos que ensamblador lo guarda en la posicion 99 memoria
mov ax,dato---->apunto a la direccion de memoria 90
mov ax,25------>no apunto a nada, sino recibe el valor inmediatamente.
mas claro ni el agua.
ahora dejemos el ensamblador, aunque es fundamental estos conceptos que son
el talon de aquiles del lenguaje ensamblador como el de redcode y que el primero dio tantos dolores de cabeza y aun lo da a muchos que empiezan.
red code.
Direccionamiento directo.
Aclaro que estos dos direccionamientos directo e inmediato los veremos mesclados.
direccionamiento indirecto se se especifica con el simbolo #.
mov #5,10------igual a mov #5,$10 ($se puede omitir)
aqui vemos los dos direcionamientos el inmediato # y el directo $
red code no tiene registros.
que quiere decir?
mueve el valor inmediato 5, a la posicion de memoria 10
es decir guarda el valor 5 en ----------------------10
esto es de inmediato a memoria(directo).
atencion no es lo mismo
mov 5,#10 en este caso 5 es una direcion de memoria que de seguro es 0, y lo que hago es apunto a esa direcion, tiene el valor 0 y se lo paso a #10. borrando el 10 y poniendo un cero.
despues de ejecuta la anterior linea se que daria la misma linea de este modo.
mov 5,#0
mov 5,#10 en este caso 5 es una direcion de memoria que de seguro es 0, y lo que hago es apunto a esa direcion, tiene el valor 0 y se lo paso a #10. borrando el 10 y poniendo un cero.
despues de ejecuta la anterior linea se que daria la misma linea de este modo.
mov 5,#0
y si hacemos esto:
mov 0,1----->vean atentamente los dos operandos son direciones de memoria. este si es un guerrero real que se auto replica su propio codigo mientras avanza por la memoria
y es uno de los mas viejo existente, se le llama Imp.
memoria
valores 00000,1,2)
00000 mov 0,1
00001
00002
aqui en red code 0 es la propia instrucion.
pues si 0 es la propia instruccion mov 0,1
pues razonemos mov (copia) lo que este en 0 (mov 0,1) a la posicion de memoria 1
pues copiara toda la instruccion. quedando asi despues de ejecutada.
memoria:(valore 0,1,2)al principio son direciones de memoria
--------
0 mov 0,1
1 mov 0,1
2otro ejemplo.
A B
mov #25,#10
en este caso tenemos dos valore inmediatos.
como lo he dicho facil de deducir ya que (la fuente va a destino)
lo que hace es mueve el valor 25 de A a B
despues de ejecutar quedaria asi.
mov #25,#25 vean desaperce el 10 podria se cualquier valorresumiendo hasta aqui.
podemos pasar de.
operando A -----a-------B o de fuente a destino
de inmediato a memoria(directo)----mov #25,10
de inmediato a inmediato ---mov #12,#0
de memoria a memoria(directo a directo) mov 8,10
de memoria(directo) a inmediato mov 8,#0 lo que estè en 8 lo mete en #0(
vemos el ejemplo de la figura.
a la derecha se ve la memoria y las instrucciones ves las direcciones de memoria son 007999,00000,000001 etc
enpesemos.
mov #25,10 mueve el valor inmediato 25 a la direccion de memoria(DM) 10
mov #12,#0 mueve el valor 12 de A a B
es decir de #12 a #0 y vean la figura despues de ejecutar, #0 pasa a hacer 12
mov 8,#0 pasa lo que estè en la DM-8 a B(#0)inmediato
me explico aqui. despues de esta linea de codigo hacia abajo la posicion 8 que es la que contiene el valor 25.
y lo meto en #0 quedando asi despues de su ejecucion
mov -2,10 el -2 significa dos instruciones arriba de esta.
copia lo que este dos direcciones arriba y metelo en la direccion 10, es decir despues de esa instruccion 10 abajo que quedaria en la direccion 000013.
pues mov -2,10 copio dies espacios mas abajo toda la instrucion
mov #12,#12
mov 6,12 mueve lo que este en la DM 6 a la direcion de memoria
12.
despues de esta instruccion 6 bloques abajo esta
esto lo coje y lo mete 6 bloques mas abajo. es decir desde mov 6,12 -- 12 bloques o espacios de memoria hacia abajo quedando asi.
Bien espero que muchos novatos como yo entiendan este tutorial yo tambien soy un novato pero mis esperimentos los he tratado de explicar de una forma mas ejemplificada. para entenderlo questa bastante y no hay muy buenos tutoriales de redcode en espagnol. si he cometido errores favor de perdonarme.
bien hasta aqui es conveniente k los nuevos empezados cojan y se pongan a modificar codigo y ver lo que pasa. la herramienta que uso es ARES. con widows 8.
Continuemos practicando una vez mas conmigo.
mov 1,$9
dat #100
coje lo que este en la direccion 1 (dat #100) y metelo en la posicion 15 de la memoria
vean la figura.
que esta en la posicion 00001? pues dat +100
que metio en la posicion 00009? pues dat 100
otro ejemplo.
mov 3,$10 ;copia lo k esta 3 posiciones abajo (nop) y lo meto en
;la DM(Direccion de memoria) 10
mov 2,$10 ;copio nop lo meto 10 espacios abajo quedaria en 00011
mov 1,$10 ;copio nop lo meto 10 espacios abajo quedaria en 00012
nop ;ejecuta nop
mov 5,$15 ;copio lo que esta en 5 espacios abajo del codigo y lo ;meto en la posicion 15 en memoria. 15 bloques abajo ;despues de la instrucion
nop
nop
nop
nop
dat #1234 ;declaro un valor de 1234
;tambien puedes poner una etiqueta con un nombre ;cuaquiera ej.
;midato dat 1234
y tambien con etiquetas puedo hacer esto.
mov midato,$15
.
.
.
midato dat #1234
vea la figuara. como quedan las instrucciones en memoria.
DIRECIONAMIENTO INDIRECTO @
SE define con el simbolo arroba (@) y afecta el campo B
es algo similar a direcionamiento directo pero la diferencia.
@ lo que dice usa el campo B al que apunto como una nueva localidad de la cual apuntar.
de otro modo:
coje el campo B y usalo como direccionamiento(apuntar)
@ siempre apunta a una posicion en memoria pero de forma indirecta.
es algo similar a $ pero no son iguales ya que @lo hace de forma indirecta.
comparemos :
dat #5,7-------------igual
mov -1,10-----------mov -1,@10
en este caso son iguales los dos.
metera el valor 7 en la casilla o memoria 10
pero si hago esto.
dat #5,10-------------igual
mov -1,10-----------mov -1,@-1
las dos instrucciones haran lo mismo.
la primera de lo hara de forma directa , la segunda de forma indirecta.
que dice el concepto? lo repito otra vez.
@ lo que dice usa el campo B al que apunto como una nueva localidad de la cual apuntar.
@-1
eso es lo que hace coje el campo B de DAT 10 al que se esta apuntando y se usara como localidad de memoria a apuntar.
y mov -1 es un direcionamiento directo que apunta a B a 10
pero como esta (mov -1 ) en A
lo unico que hace es apuntar a B de la primera instrucion,
tomar ese valor . B lo coje y lo empuja o mueve de forma indirecta a un luga en memoria.
se que es dificil de entender, es un puntero que apunta a una localidad de memoria en la que se encuentra un dato o una instruccion y la usara como para apuntar a una posicion en memoria.
veamos ejemplos para entenderlo. la practica hace al monje la teoria lo complementa.
mov #35,$5--->de inmediato a memoria
y
mov #17,@5--->de inmediato a memoria inmediata
se comportan iguales como el ejemplo anterior.
cuando mov #35,5 se ejecuta mueve el valor 35 a la posicion de memoria 000005. aclaro se dio el caso que se mueve a 00005 por que la instruccion estaba en 0 y a partir del 0-1,2,3,4,5 hay 5 casillas o bloques de memoria.
lo que hace es mover desde donde se ejecuto 5 casillas abajo.
ven la segunda si contamos desde donde se ejecuto hacia abajo hay 5 casillas y mueve el valor 17.
en este caso se comportan iguales veamos otro ejemplo.
veamos los dos juntos para ver su diferencia.
mov #35,@1
mov #1,5
se ejecuta mov #35,@1 que pasa:
mueve el valor 35 a....
donde ?
a donde apunta B (@+1) --- a la instruccion de abajo a B de mov #1, 5. coje el 5 y lo usa como localidad de memoria.
bien mueve 35 a la posicion 5 a partir de la segunda instruccion.
veamos que pasa cuando se ejecuta la segunda instruccion.
vean borro el 35 que estaba en 00006 y metio 1
vean que este direcionamiento si movio el valor inmediato 1, 5 casillas abajo.
estos programa,etos ejemplos son a modo de entendimiento.
no hacen nada.
otro ejemplo:
add #4,#0
mov #35,@-1
en este caso la primera instruccion agrega 4 al capo B (0)
despues de ejecutarlo B (=4)
-la segunda instruccion mueve 35 a la posicion que apunta B.
B es igual a @ - 1 ?y que es -1?
es el campo B de add que despues que se ejecuto es = 4
bien -1 ==== 4
@ es el mismo capo a donde apunto -1 (4)
pero ahora es @=4-1 = 3 vean que despues -1 lo coje como un simple valor.
bien resumiendo @-1 === 4-1 ==== 3
y 3 es la cantidad de bloques que movera el valor 35
mueve (mov) el valor 35 al la posicion o bloque 3 despues
de mi(despues de mov #35,@-1)
vean la figura:
despues que lo ejecutamos nuevamente.
el campo B de add pasa a 8
y la segunda instrucion mueve 35 a @-1===8-1=7
y si seguimos ejecutando.
1- vale 12,16,18,22
2- mueve 35 a 11,15,17,21
y si al final de la instruccion agregamos
jmp -2 quedando asi.
add #4,#0
mov #35,@-1
jmp -2
jmp -2 apunta de nuevo a la primera instruccion crando un bucle
tambien se podia crear creando etiquetas
start
add #4,#0
mov #35,@-1
jmp start
y este si que es un prgrama que bombardea la memoria con el dato 35,35,35,35 etc cada 3 espacios en memoria
analicelo, ejecutelo.
si a este programa lo modificamos y donde esta move #35,@-1
ponemos mov 0,@-1
0 es la propia instruccion. (mov 0,@-1)
con cero siempre apuntamos a la propia instruccion.
pues lo que hace es copiar la misma instruccion y metela en memoria cada 3 bloques de memoria
vean la figura.
add #4,#0
mov 0,@-1
jmp start
bien veamos un bomber que es un programa mas sosfisticado que un IMP (mov 0,1) este ultimo se copia asi mismo en cada paso que da en la memoria de uno en uno solo hace eso.
el segundo agrega datos a la memoria como el anterior.
este es el famoso Dwarf. veamos su codigo.
start ADD #4,bomb
MOV bomb, @bomb
JMP start
bomb DAT #0,#0
este tiene etiquetas. sin etiquetas seria asi.
add #4,3
mov 2,@2
jmp -2
dat #0,#0
veamos que hace espero que a este nivel ya sepa como funciona.
1-agrega 4 a lo que esta en dat (3 instrucciones mas abajo.
2-muevo lo que este en dat (4 dos instrucciones abajo)a la posicion 4+2 =6
esta instrucion puso 4 en la memoria 6 instruciones abajo de su ejecucion.
3-regresa al principio.
segundo ciclo
1-agrega 4 a 4 =8 en dat ahora dat vale 8
es decir quedaria dat quedaria en dat 8
2-mueve lo que esta en dat (8) a la posicion @2 (8+2=10) posicion 10
3 retorna
y asi sucesivamente.
el bucle va aumentando de 4 en cuatro 4,8,12,16,20
y esos valore los mete en la memoria, si un programa trata de ejecutar un dato como una instruccion pierde por que dat no es una instruccion sino un dato.
algunos ejemplos simples para que ud practique.
EJEMPLOS DE PRACTICA.
hagalos ud mismo y vea lo que hace
add #5,#10
mov #5,#0
add -1,#2
add #21,8
add 7,#5
add #4,-1
org start
dat #6
dat #0
start
add -2,-1
add #4,-2
add -3,10
add -4,#20
end
mov #5,#0
add #1,-1
mov #0,-2
mov #10,-3
mov -4,11
mov #0,-5
mov #0,-5
mov #0,-5
mov #0,-5
mov #0,-5
add #5,7
add 3,#4
nop
nop
dat #0,#3
;en este caso add agrega lo k esta en dat a B de add
;es decir despues de ejecutar quedaria asi
; add 3,#7
;y si ejecuta otra vez queda asi
;add 3,#10
;---------------------------------------
;ahora veamos esto:
add #3,4
nop
nop
nop
dat #0,#0
;en este caso add agrega 3 dat, despues de ejecutado
;queda dat =3 y si se ejecuta otra vez dat=6
;9,12,15,18 etc
Mencionemos como muere un programa.
no se por ahora si hay mas por mi nivel de principiante mas alante si reconosco otras lo menciono.
1-bien si un programa trata de ejecutar un dato se considera ilegal y se pierde.
dato es una DAT
2-si un programa ocupa en memoria lo de otro es decir mete su codigo en su instruccion eliminado de esa forma el codigo del segundo.
3-tambien puede un programa eliminar la instruccion que hace mal al segundo y lo deja inoperante hasta que el segundo ocupe todo su espacio.
bien veamos un ejemplo del primer tipo.
y este es de forma educativa para ver como funciona.
si se ejecuta un dat como una instruccion se muere.
ejemplo:
mov 1,-9
nop
nop
nop
dat #5
jmp -5
en este programa la primera instrucion mueve lo que este en la pocicion 1 y lo mete en -9 por arriba de su instrucion. esto no hace nada es tan solo por poner una instruccion.
los nop no hacen nada solo espacio que ocupan
ahora llegamos a la muerte.
dat #5
vean que esta dentro del programa de ciclo entre la primera instruccion y el jmp -5
como esta dentro se trata como una instruccion y como una dat no se puede tratar como una instruccion y que valga la redundancia. pues el una ilegalidad o un error de codigo en tratar un dat como instruccion y el programa crash y se pierde
ni tan siquiera llega al jmp
vean la figura:
veamos que pasa cuado llega a la instruccion dat y trata de ejecutarla.
vean el color rojo en D (D es de dato) lo mete en rojo por que es ilegal.
ahora estamos en 000006 nop y la proxima instruccion es el dat en 000007. la ejecuto y.....
no llega a jmp sino que salta esta y el programa no se puede ejecutar mas.
es el momento de la primera figura donde esta el cuadradito rojo.
pues esto mismo es lo que hace un oponente.
trata de meterte un dato para que se ejecute como una instruccion.
veamos que el mismo ejemplo muere el mismo es decir se elimina el mismo contra un Dwarf
el primero se ejecuta primero y esta en la posicion 0
el segundo ni tan siquiera lo elimina. este ultimo esta en la posicion bien lejana del primero en 5188.
primero se ejecuta la primera instruccion del primer programa despues la primera instruccion del segundo y asi sucesivamente.
y sucede lo mismo el primero muere el solo(se mata el mismo)
guerreros :
1ro muere.red
2do bomber.red que ya lo vimos antes. es un bomber.
gana bomber. pero el no lo mato. sino que muere se mato el mismo por eso gana bomber.
Ahora veamos como uno le mete un Dat al otro para que lo ejecute como una instruccion.
en este caso meto a bomber que ya conocemos como primer guerrero. en 0 y muer lo meto en la posicion 10.
muere va a matar a bomber de la forma ya dicha, metiendo un dat en su codigo para que bomber lo ejecute como instruccion.
dejo imagen que habla mas que palabras.
el verde es bomber --azul muere
vean bomber.red en 0, muere en 10
aun no se ha ejecutado nada
bien ejecutamos el primero es bomber que ejecuta su primera instruccion, agrega 4 a dat. dat (4)
biene el turno a muere ejecuta su primera instruccion. mueve lo que este en en -7 (DAT #4) en la segunda instruccion de bomber. es decir mueve DAT #4 en mov 2,@+2 espero se entienda.
cambia mov +2,@+2 por DAT#4 ASI cuando le toque el turno a bomber que es en la segunda vuelta este trata de ejecuta un Dat y pierde.
bien dejo una imagen cuando todo esto paso compare las dos imaagenes.
vean muere es el ganador (The winner es muere)
Todos estos ejemplos lo tube que ir recreandolos mientras iba aprendiendo y lo plasmaba en este tutorial por que los tutoriales estan todo en ingles y cuando se habla se dice muchos conceptos sin ejemplos y no se entiende nada si no se ejemplifican.
espero le sirva a muchos.
DIRECIONAMIENTO INDIRECTO SEGUNDA PARTE (@) sobre el campo B
Otra forma de direcionamento indirecto.
opcode A-----@B esto ya lo vimos
ej. mov #5,@2 , mov 5,@5 etc
siempre @ opera en el operando B
pero veamos este caso cuando @ esta en A.
auque este en A el direcionamiento indirecto siempre operara sobre el capo B de una instruccion.
ejemplo
mov @1,10
add #2,2
jmp
dat #3
pues mueve lo que esta en el campo B de la instruccion Add
A Badd #2, 2
a la posicion 10
pues no es asi.
pero vean por que es indirecto
realmente lo que hace es.
mueve lo que esta en @1 que es B de add, pero el campo B de add apunta a Dat 3, pues al ejecutarse la primera instruccion
ya coje lo que esta en dat que fue apuntado indirectamente por el campo B y lo mete en la posicion 10
es decir:
cuando se ejecuta mete el valor 3 de dat en la casilla 10
despues add #2,2 le agrega 2 a dat, ahora dat vale 5
jmp
y empezamos denuevo
dat ahora es 5.
me ahorro toda la explicaion anterior y voy al grano.
muevo 5 a 10
add 2 a 5 =7
jmp
denuevo:
muevo 7 a 10
add 2 a 7 =9
jmp
y asi se va aumentando la casilla 10, a 3,5.7.9,11 etc
vean la figura cuando ya esta 10 en el valor 11.
existe tambien esta posibilidad.
mov @A, @ B
ejemplo simple:
org start
start
mov #35,10
mov @-1,@12
add #1,-1
jmp start
bomb dat 50
end
explicacion.
1-mueve 35 a la posicion 10
2-y ahora viene lo terrible de explicar. talvez sea que no hay tanta documentacion.
vamos por paso.
mov mueve,@ es un puntero a un lugar en memoria y influye en el B, el otro @ la misma explicacion.
hagamoslo con preguntas.
-mueve ? que muevo?
pues mueve dato que esta en un puntero o mueve un dato que hace referencia a un lugar en la memoria.
mov @-1 apunta a 10 de la instrucion anterior y ese 10 es un direccionamiento hacia la casilla 10 en memoria que tiene el valor 35. pues mov @-1 coje ese 35 de la casilla 10(atencion no lo coje de mov #35,...)
vean las franjas verdes. son a donde se apunta cuando se ejecuta
mov @-1,@12 ---de 1 --->0 de 0 a ------000010-----000013
vea abajo lo de @12.
-la otra pregunta.
?a donde lo muevo?
@12
lo muevo a otra direcion de memoria. 12 posiciones o casillas mas abajo.
podia haber hecho esto.
mov @-1,12
pero puse este ejemplo ya que requeria ejemplarizar
opcode @ A, @ B.
3-agrega #1 a la instruccion anterior(mov @-1,12) en el campo B
ahora pasa de 12 a 13
y cuando se ejecute el ciclo otra vez metera 35 en la posicion 13
y asi sucesivamente.
mov
MOV # A #B
MOV # A B
MOV A #B
MOV A B
MOV # A @
MOV A @ B
MOV @ A B
MOV @ A @ B
esta son posibles combinaciones que hasta ahora hemos visto.
esto no solo es aplicaple a mov sino a otras instrucciones
como add,jmp,sub,cmp,spl,djn,jmz,slt jmn.
Direccionamiento indirecto sobre el campo A.(*)
hasta ahora hemos visto manipulaciodes del campo B pero demos de tener la posibilidad de mosdificar, direccionar, etc tambien el capo B para eso esta este modo de direcionamiento
indirecto sobre el campo A y se representa con el simbolo .
start
add #1,1
mov #33,1
jmp -2
mov 1,*1------
num dat #2-- | , #10----|
3.. !
4..dat 10-----------------
aqui es mueve lo que esta en 10 de dat
a donde ? mov 1 apunta al campo B de dat a 10 y *1 apunta al campo A de dat 2
movera 10 dos bloques abajo de dat.
como es indirecto movera el dato desde donde apunto.
no desde mov sino desde donde a apuntado. desde dat
NOTA.
HE cometido un error de explicacion en los casos anteriores referido a redireccionamiento indirecto.
cuando dije @-1 aunque si lo quiere tomar asi tambien sera valido.
no quiere decir por ejemplo en:
dat #5
mov 0,@-1
no es @-1 ---5-1=4 aunque coincide que despues del mov hay 4 bloques abajo mete el dato 5
0--dat #5-------*-->------
^ |
| |
1--mov 0,@-1---- |mueve la instrucion 5 hacia abajo
2-- |a partir de dat
3-- |
4-- |
5--mov 0,@-1 <-----------
en realodad es que -1 apunta a dat y @ recoje el valor 5 y ese 5 es el movimiento que hara a partir de dat.
seria mueve este mismo codigo
a donde?
a la direcion que apunta B
donde apunta B?
a -1. ?que es -1? -----dat #5
dat #5 se mete en @ (@=5)y ese valor la cantidad de movimentos a hacer pero lo hara indirectamente a partir de dat.
Direccionamiento indirecto con predecremento en el campo B <
Este tipo de direccionamiento indirecto es mas moderno y usa el simbolo < y afecta el campo B. Es similar al direccionamiento indirecto @ pero con la peculiaridad que el puntero va a decrementar en uno antes que la direccion B o (dierccion destino) sea calculada.
Este tipo de direccionamiento es mas moderno, los primeros direcionamientos que usaba la primera version de core war solo usaban $,#,@.
veamos y comparemos con el direccionamiento de memoria indirecto @.
recuerde este usa el campo B a la cual se apunta como una direcion de memoria.
dat #0,#10
mov #15,@-1
mueve el valor 15 a donde apunta @
?a donde apunta @-1 ?
apunta a #10 de dat y coje ese #10 como una direcion de memoria no como un valor inmediato.
bien entoces apunta a la direccion 10 a partir de dat
movera 15 a 10 posiciones por debajo de dat en memoria.
bien indirecto con predecremento hace lo mismo pero decrementa el puntero en cada ejecucion de el.
veamoslo en un ej para que se entienda mejor.
dat #0,#8
mov #35,<-1
vamos por pasos. veamos el campo B de mov.
es igual al direcionamiento indirecto @ solo que decrementa el puntero al cual esta apuntando a dat 8 (lo decrementara a 7)
entonces <-1 es #8 de dat
y < es un puntero indirecto que apunta a direcion de memoria 8
igual a @. pero
en este caso como dice el concepto de este tipo de puntero primero decrementa el puntero y despues calcula la direccion de memoria.
entoces decrementa 8 en uno, seria 7 y ahora calcula la direccion de memoria que es 7.
en otras palabras resto uno a donde apunto y esa sera la direccion de memoria. 7
mueve #35 , a 8 decremento 8 (8-1)7 y el 35 va a la posicion 7en memoria.
vea la imagen despues de ejecutar mov #35,<-1
no se limite tan solo a leer, tambien practiquelo ud mismo asi vera lo que hace y lo entendera mejor.
espero se haya entendido son conceptos dificiles de explicar.
y recuerde este tipo de direcionamiento afecta el campo B a donde se apunta. siempre apunta a B.
si el ejemplo anterio se ejecuta denuevo.
mueve 35 a , (7-1=6) a la direccion 6
y asi.
atencion este es un ejemplo para entender el concepto de este direccionamiento.
ya que si sigue ejecutando metera 35 en todas las instrucciones
hasta que se ejecute un dat .
pruebe ud mismo.
donde estan las instruciones metera dat #35 y muere el programa. pero es para que se vea su funcionamiento.
ahora probemos esto:
dat #0,#8
start
mov <-1 ,#35
end
que creen que pasara?.
mueve lo que este en (8-1)=7
que hay en 7, nada 0
eso lo metera en 35
cambiara 35 por 0.
pero vea como decrementa el puntero a dat 7.
repita los pasos varias veces.
vea los sgtes ejemplos
org start
dat #0,#8
start
mov #21,6
mov <-2 ,#35
end
dat #0,#8
start
mov #21,6
add <-2 ,#35
end
org start
dat #0,#8
start
mov #21,6
add #35,<-2
end
dat #0,#8
start
mov #21,6
mov <-2,9
end
atencion si apuntamos a un valor negativo entonces < que disminuye en 1 a donde apunta hara lo contrario, aumentara de uno en uno comportandoce como >.
ejemplo:
ORG start
dat #-8 ;tiene un valor negativo
start
mov -1,<-1
end
-8 y -1 =9
incrementa como en > y depues mueve a ese valor apuntado 9
movera -8 a la posicion 9
ya dat tiene 9
si continua.
-9 y -1 =10
incrementa dat a 10 y mueve el -9 a la posicion apuntada 10
comapare este ejemplo con:
ORG start
dat #8 ;tiene un valor positivo
start
mov -1,<-1
end
vera en este segundo como el puntero a dat 8 disminuye y como es positivo mete los datos por debajo no por arriba como el primero.
Direccionamiento indirecto con postincremento en el campo B >
el mismo concepto que el anterior y afecta el operando B a donde se este apuntando o influye en ese campo.
la diferencia radica en que incrementa el puntero.
y tambien que primero evalua la direccion y depues incrementa
es decir lo que esta en el puntero sera la direccion a tomar y despues incrementa.
-el aterior primero decrementa y despues evalua la direccion siendo esta ultima la direccion a tomar.
dat #0,#8
start
mov #35,>-1
end
vea la imagen
tadavia no se a ejecutado.
despues de ejecutar. quedaria asi.
si lo sigo ejecutado.
practique con los ejemplos del anterior direccionamiento modificandolo y usando >
{ direccionamiento indirecto para el campo A predecremento
se usa el simbolo { y este afecta el operando A o tomara el campo A como puntero o modificara ese campo.
primero modifica el campo decrementandolo en 1 y tomandolo como nueva evaluacion de puntero o movimiento.
digamos si el campo a es dat #5,#8 el 5 lo decrementa a 1, sera 4 y el cuatro lo coje como puntero a memoria.
vea el ejemplo.
dat #5,#8
start
mov #35,{-1
end
mueve 35 a la direccion de memoria donde apunta {-1 que es el campo A de dat 5-1=4
movera 35 a la direccion dde memoria 4 a partir de dat.
vea la fig aantes de ejecutar.
despues de ejecutar .
depues de ejecutar otras dos veces
repito use los ejemplos anteriores con este tipo de direcionamiento agregue dos campos en A
ejemplo:
dat #2,#9
y cambie en las instrucciones a { donde sea pertinente.
practique.
} direccionamiento indirecto para el campo A postincremento
Supongo que a este nivel ya sabra como funciona, iden al direcionamiento indirecto del campo B postincremento.
primero toma el puntero como movimiento de memoria ejemplo si es 5 coje el 5 como movimiento de memoria despues incrementa y asi sucesivamente.
org start
dat #5,#8
start
mov #35,}-1
end
mueve el 35 5 casillas abajo de dat y despues incrementa dat a 6.
mueve 35 6 casillas abajo de dat despues incrementa dat a 7
y continua igual incrementando el puntero de uno en uno.
USO DE LAS INSTRUCIONES.
instruccion add.
Uso de ADD. este ya lo hemos tratado en los anteriores ejemplos pero retoquemoslo, al igual que su definicion.
add significa agregar o sumar.
y va desde el campo A al B, influyendo el campo B
lo que va en A(fuente) es lo que se afregara a B.
recuerde no solo numeros inmediatos sino tambien direciones de memoria.
6
ejemplo:
dat #0,#33
add -1,#7
simple para entenderlo mejor.
-1 de add es direccionamiento directo apunta a 33 dedat
agrega 33 al campo B de add (7)
suma 33 a 7 =40 resultado.
este es aun mas simple y comun de los ejemplos.
add #5,#10 ;agrega 5 a B (10) resultado 15
otro igual al anterior pero con dos direcionamientos directos y etiquetas en dat.
num dat #10
num2 dat #10
add num,num2 ;
que es A? un direcionamiento ind... apunta a num (10)
que es B? lo mismo............... aounta a num2 (10)
que hace?
agrega o suma num a num2 ---10+10
igual a 20
quedando asi despues de su ejecucion.
num2 dat #20
se pueden crear todas estas combinaciones
A B
#$ @<> {} --- inmediato ---a---- inmediato y a memoria
$@<>{} # ----de memoria a inmediato
$@<>{} $@<>{} ---de memoria a memoria.
cuando digo memoria me refiero a distintos tipos de direccionamientos.
veamos otros mas.
ya vimos de inmediato a inmediato.
direto $ a inmediato
directo a directo.
vamos a primero con
#----@
ORG start
num dat #4
num2 dat #10
start
add #5,@num ; igual a @-2
nop
nop
nop
end
figura:
@es indirecto, recuerde coje a donde apunta como puntero
@-2 o @num apuntan a dat #4 el cuatro se coje como puntero para direccionar a memoria.
agrega 111 a la posicion 4 de memoria por debajo de dat.
como en esa posicion habia un nop por defecto b es 0
0+111=111
si en es posicion hubiese un valor se habria sumado.
comoen este caso.
ORG start
num dat #4
num2 dat #10
start
add #111,@num ; igual a @-2
nop
sub #2,#8
nop
end
sub #2,#8 sumara 111+8=119
una imagen habla por 1000 palabras despues de ejecutar
add #111,@num .
#-----< de indirecto a indirecto campo B predecremento
dat #8
add #71,<-1
pruebe .
#------ >
modificado el codigo anterior.
vea este de .indirecto sobre el campo A
#-----{
dat #5,#9
start
add #71,{-1
nop
nop
add #25,#10
end
agrega 71 a donde apunta {-1 al campo A de (dat 5)
primero decrementa 5-1=4. 4 hacia abajo sin contar start es
add #25,#10.
suma 71 +10 =81
modifique el anterior ajemplo y use.
#---- } indirecto post incremento campo A
ya vimos de #-----memoria.
nota.debe de practicar bastante.
vea que estos ejemplos son simples pero que abarcan los conceptos fundamentales de direccionamientos sino los interioriza y los estudia hasta el cansancio, pasara que cuando vea un codigo de un guerrero que su codigo es mas complicado no lo entendera. si se a familiarizado los entendera mas o menos que es mejor que nada. despues con la practica le sera mas facil.
veamos de memoria a #indirecto.
dat #2,#3
dat #0,#0
dat #0,#7
add @-3,#7
add-agrega lo que apunta @-3 (dat #2,#3) del campo A (3) lo coje como puntero, 3 apunta 3 casillas abajo al campo B de add (7) ok tenemos que ya add @-3 vale 7 y lo sumamos a 7 del campo B de add. 7+7=14
vea add @-3,#7 ya no tiene 7 sino 14
asi podemos continuar de forma simple con los otros que faltan.
seria un enorme tutorial si continua con mas ejemplos con la instruccion add. modifique el codigo y hagaslo ud asi se entrena y coge soltura con las instrucciones.
instruccion MOV ya la he tratado y no repetire.
solo recordar mueve del campo A a B.
instruccion SUB: lo contrario de add. en palabras simples se usa para restar o substraer lo que esta en el campo A al campo B.
ejemplo simple
sub #5,#25 ;substrae 5 a 25 =20
el campo A afecta al campo B de sub, es decir almacenara la resta en B
quedaria #5,#20 ;despues de su ejecucion.
las distintos movimientos que podemos hacer son:
A B
#$ @<> {} --- inmediato ---a---- inmediato y a memoria
$@<>{} # ----de memoria a inmediato
$@<>{} $@<>{} ---de memoria a memoria.
ORG start
uno dat #2,#3
dos dat #0,#0
tres dat #0,#7
start
add uno,tres
sub #2,tres
end
primero agrego 3 a 7 seria 3+7=10
ahora tres en B tendra 10
substraigo 2 a tres, ahora tres que era 10 tiene 8
10-2
ORG start
uno dat #2,#3
dos dat #0,#0
tres dat #0,#7
start
add uno,tres
sub #2,<tres
nop
nop
nop
nop
nop
nop
mov #1,#9
end
add-suma 3 a 7 =10 ---tres vale 10 ahora
sub-resto 2 a lo que apunta B (<tres) apunta al nuevo 10 de tres. tres apunta a mov #1,#9
por debajo de tres hacia abajo hay 9,recuerde < decrementa de 10 a 9 por eso apunta 9 hacia abajo.
bien sub 2 - 9 =7
mov #1,#9 de nueve pasara a tener 7
instruccion MUL:
se usa para la multiplicacion.
multiplica el campo A al campo B y guarda el resultado en el campo B.
mul #5,#5
despues de ejecutarse sera mul #5,#25
num db 10
num2 db 10
start:
mul num,num2
despues de su ejecucion
el num2 valdra 100
las distintos movimientos que podemos hacer son:
A B
#$ @<> {} --- inmediato ---a---- inmediato y a memoria
$@<>{} # ----de memoria a inmediato
$@<>{} $@<>{} ---de memoria a memoria.
Instruccion DIV:
se usa para division.
divide el campo A al campo B
atencion B es el dividendo y A el divisor. Es decir si queremos dividir 25/5, 25 va en B y 5 en A.
yo suelo decir asi. divide 5 a 25.
div #5,#25
despues de su ejecucion el campo B de div valdra 5
div #3,#20
20/3=6 y el resto 2
por que 6x3=18
el campo B de div =6
las distintos movimientos que podemos hacer son:
A B
#$ @<> {} --- inmediato ---a---- inmediato y a memoria
$@<>{} # ----de memoria a inmediato
$@<>{} $@<>{} ---de memoria a memoria.
Instruccion MOD:
divide el campo A entre B y retorna el resto de la division en el campo B
igual a div. ejemplo mod 3 a 20
20/3=6 (6x3=18) sobran 2
ese 2 es el que pasa al campo B de MOD.
mod #3,#20 despues de su ejecucion queda asi
mod #3,#2
las distintos movimientos que podemos hacer son:
A B
#$ @<> {} --- inmediato ---a---- inmediato y a memoria
$@<>{} # ----de memoria a inmediato
$@<>{} $@<>{} ---de memoria a memoria.
todo esto se puede combinar por ejemplo con saltos despues lo veremos en el proximo capitulo digamos si la division de dos numeros el mod es 0 haz una cosa o de lo contrario haz otra.
lo mismo que con add,sub,mul,mov etc.
vea que en las ultimas instrucciones no he puesto muchos ejemplos ya que puede ud tomar los de los anteriores y aplicarlos a estos ultimas instrucciones inclusive los que ud se imagine.
trate de calcular ejemplo sin un numero es primo,el radio de una circunferencia, todo lo que ud se imagine. para practicar aunque el juego no tiene que ver con calculos especiales de matematicas, pero si sirven de ejercitacion de las instrucciones. En el momento de escribir no he querido poner mas jemplos talvez en otro momento incluya otros.
Uso de las instruciones de salto o condiciones.
JMP
JmZ A,B este tipo de condicion evalua si el campo B (puede ser una direcionamiento) es cero, si es cero salta a donde apunta A, de lo contrario continua en la proxima instruccion.
org start
;datos
num2 dat #0
start
jmz ciclo,num2
nop
nop
etiqueta1:
nop
nop
etiqueta2:
nop
nop
ciclo jmp start
end start
explicacion:num2 tiene el valor 0
por lo que se cumple la condicion de jmz las demas instrucciones por debajo de jmz ciclo,num2 no se ejecutaran, como es 0 saltara a la etiqueta ciclo y se repetira continuamente.
ahora cambie num2 el valor de 0 a un numero digamos 2 ahora no se cumple la condicion de jmz y se ejecutaran todas las instrucciones por debajo de jmz. el ciclo se repetira continuamente pero pasara por todas las instrucciones.
ahora veamos otro:
veamos un ejemplo sencillo calculemos todos los numero del 1 al 10 si son impares, ya sabe si un numero dividido entre 2 e resto de la division no es 0 entonces es impar.
si es par el resto de la division =0
usaremos la instruccion mod que nos da el resto de la division.
solo veamos por el momento los pares.
org start
;datos
numero dat #10
num2 dat #0
start
mov numero,num2
mod #2,num2
jmz par,num2
nop
nop
resta: sub #1,numero
jmp start
par: mov num2,8
add #1,par
jmp resta
end start
este ejemplo se puede hacer de muchos modos pero usare este metodo mas simple de explicar.
he usado dos variables numero y num2 num2 sera igual a numero pero se afectara a 0 si es par asi no se afecta numero.
es decir trabajo sobre num2 para saber si es par.
1.muevo el valor de numero a num2 ---10 a 10 num2 valdra 10 en el primer giro del ciclo.
2.mod 2 a num2 --vemos si 10/2 el resto es 0-->si lo es.
3.jmz ..salta a la etiqueta par si num2 es 0--->pues salta por que 10 es par.
ya estamos en :
par: movemos num2=0 a la posicion de memoria 8
add #1,par---incrementa en 1 el campo B de par (de 8 a 9)
asi cuado se repita el ciclo nuevamente y sea par lo guardara en una posicion de memoria contigua.
jmp resta: saltamos a resta: le restamos 1 a numero (10-1=9)
jmp start : comenzamos.
analizamos ahora que numero es igual a 9
1.muevo el valor de numero a num2 ---9 a num2 valdra 9 en este giro del ciclo.
2.mod 2 a num2 --vemos si 9/2 el resto es 1-->no es par. como no es par se ejecutaran las instrucciones por debajo de este. no saltara a ciclo sino que se ejecutara la proxima instruccion.
nop
nop
resta: sub #1,numero
jmp start
llega a la etiqueta resta
le substrae 1 a numero (9-1=8)
salta a start.
y continuara.
modificadores.
.A A -> A
.B B -> B
.AB A -> B
.BA B -> A
.F A->A and B->B
.X A->B and B->A
.I Entire instruction
Opcode A-mode B-mode modifier
1509 ------------------------------------------------
1510 DAT #$@<> #$@<> F
1511 MOV,CMP # #$@<> AB
1512 $@<> # B
1513 $@<> $@<> I
1514 ADD,SUB,MUL,DIV,MOD # #$@<> AB
1515 $@<> # B
1516 $@<> $@<> F
1517 SLT # #$@<> AB
1518 $@<> #$@<> B
1519 JMP,JMZ,JMN,DJN,SPL #$@<> #$@<> B
1520 ----------------------------------------------