@ -1719,19 +1719,6 @@
; ATAN: Incrementa cont-prg en 1, quita de la pila un elemento numerico, calcula su arcotangente y la coloca al final de la pila.
; ABS: Incrementa cont-prg en 1, quita de la pila un elemento numerico, calcula su valor absoluto y lo coloca al final de la pila.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; No puedo usar or a secas:
; Can't take value of a macro: #'clojure.core/or
( defn or-diadico [ arg1 arg2 ]
( or arg1 arg2 )
)
; No puedo usar and a secas:
; Can't take value of a macro: #'clojure.core/and
( defn and-diadico [ arg1 arg2 ]
( and arg1 arg2 )
)
( defn interpretar [ cod regs-de-act cont-prg pila mapa-regs ]
( let [ fetched ( cod cont-prg ) ,
opcode ( if ( symbol? fetched ) fetched ( first fetched ) ) ,
@ -1878,22 +1865,6 @@
POPADD ( let [ res ( asignar-aritmetico regs-de-act pila reg-actual fetched + ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; POPSUB: Como POPADD, pero resta.
POPSUB ( let [ res ( asignar-aritmetico regs-de-act pila reg-actual fetched - ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; POPMUL: Como POPADD, pero multiplica.
POPMUL ( let [ res ( asignar-aritmetico regs-de-act pila reg-actual fetched * ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; POPDIV: Como POPADD, pero divide.
POPDIV ( let [ res ( asignar-aritmetico regs-de-act pila reg-actual fetched dividir ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; POPMOD: Como POPADD, pero calcula el resto de la division.
POPMOD ( let [ res ( asignar-aritmetico regs-de-act pila reg-actual fetched rem ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; Incrementa cont-prg en 1 y quita el ultimo elemento de pila. El argumento indica en reg-actual las coordenadas [#reg-act, offset] donde sumar el elemento en regs-de-act al llamar recursivamente a interpretar (verificando la compatibilidad de los tipos)
; Por ejemplo:
; fetched: [POPADDREF 2]
@ -1908,22 +1879,6 @@
POPADDREF ( let [ res ( asignar-aritmetico-ref regs-de-act pila reg-actual fetched + ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; POPSUBREF: Como POPADDREF, pero resta.
POPSUBREF ( let [ res ( asignar-aritmetico-ref regs-de-act pila reg-actual fetched - ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; POPMULREF: Como POPADDREF, pero multiplica.
POPMULREF ( let [ res ( asignar-aritmetico-ref regs-de-act pila reg-actual fetched * ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; POPDIVREF: Como POPADDREF, pero divide.
POPDIVREF ( let [ res ( asignar-aritmetico-ref regs-de-act pila reg-actual fetched dividir ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; POPMODREF: Como POPADDREF, pero calcula el resto de la division.
POPMODREF ( let [ res ( asignar-aritmetico-ref regs-de-act pila reg-actual fetched rem ) ]
( if ( nil? res ) res ( recur cod res ( inc cont-prg ) ( vec ( butlast pila ) ) mapa-regs ) ) )
; Incrementa cont-prg en 1, quita de la pila dos elementos, calcula su suma y la coloca al final de la pila
; fetched: ADD
; pila recibida: [1 0 0 3 4]
@ -1932,18 +1887,9 @@
( if ( nil? res ) res ( recur cod regs-de-act ( inc cont-prg ) res mapa-regs ) ) )
; PUSHFI: PUSH FROM INSTRUCTION. Direccionamiento inmediato. Incrementa cont-prg en 1 y agrega al final de pila el valor del argumento.
PUSHFI ( let [
res ( conj pila ( second fetched ) )
]
PUSHFI ( let [ res ( conj pila ( second fetched ) )
( recur cod regs-de-act ( inc cont-prg ) res mapa-regs )
)
; PUSHFM: PUSH FROM MEMORY. Direccionamiento directo. Incrementa cont-prg en 1 y agrega al final de pila el elemento ubicado en la posicion de reg-actual indicada por el valor del argumento.
PUSHFM ( let [
res ( conj pila ( second ( reg-actual ( second fetched ) ) ) )
]
( recur cod regs-de-act ( inc cont-prg ) res mapa-regs )
)
] )
; NOT: Incrementa cont-prg en 1, quita de la pila un elemento booleano, lo niega y lo coloca al final de la pila.
@ -2017,92 +1963,6 @@
; SUB: Como ADD, pero resta.
SUB ( let [ res ( aplicar-operador-diadico - pila ) ]
( if ( nil? res ) res ( recur cod regs-de-act ( inc cont-prg ) res mapa-regs ) ) )
; OR: Como ADD, pero calcula el or entre los dos valores
OR ( let [ res ( aplicar-operador-diadico or-diadico pila ) ]
( if ( nil? res ) res ( recur cod regs-de-act ( inc cont-prg ) res mapa-regs ) ) )
; AND: Como ADD, pero calcula el and entre los dos valores.
AND ( let [ res ( aplicar-operador-diadico and-diadico pila ) ]
( if ( nil? res ) res ( recur cod regs-de-act ( inc cont-prg ) res mapa-regs ) ) )
; SQRT: Incrementa cont-prg en 1, quita de la pila un elemento numerico, calcula su raiz cuadrada y la coloca al final de la pila.
SQRT ( let [
res ( Math/sqrt ( last pila ) ) ,
nueva_pila ( assoc pila ( - ( count pila ) 1 ) res )
]
( recur cod regs-de-act ( inc cont-prg ) nueva_pila mapa-regs )
)
; SIN: Incrementa cont-prg en 1, quita de la pila un elemento numerico, calcula su seno y lo coloca al final de la pila.
SIN ( let [
res ( Math/sin ( last pila ) ) ,
nueva_pila ( assoc pila ( - ( count pila ) 1 ) res )
]
( recur cod regs-de-act ( inc cont-prg ) nueva_pila mapa-regs )
)
; ATAN: Incrementa cont-prg en 1, quita de la pila un elemento numerico, calcula su arcotangente y la coloca al final de la pila.
ATAN ( let [
res ( Math/atan ( last pila ) ) ,
nueva_pila ( assoc pila ( - ( count pila ) 1 ) res )
]
( recur cod regs-de-act ( inc cont-prg ) nueva_pila mapa-regs )
)
; ABS: Incrementa cont-prg en 1, quita de la pila un elemento numerico, calcula su valor absoluto y lo coloca al final de la pila.
ABS ( let [
res ( Math/abs ( last pila ) ) ,
nueva_pila ( assoc pila ( - ( count pila ) 1 ) res )
]
( recur cod regs-de-act ( inc cont-prg ) nueva_pila mapa-regs )
)
; FLUSH: Purga la salida e incrementa cont-prg en 1.
FLUSH ( do ( flush ) ( recur cod regs-de-act ( inc cont-prg ) pila mapa-regs ) )
; NL: New line. Imprime un salto de linea e incrementa cont-prg en 1.
NL ( do ( println ) ( recur cod regs-de-act ( inc cont-prg ) pila mapa-regs ) )
; JMP: Salto incondicional. Cambia cont-prg por el valor del argumento.
JMP ( recur cod regs-de-act ( second fetched ) pila mapa-regs )
; JC: Salto condicional. Quita el ultimo valor de la pila. Si este es true, cambia cont-prg por el valor del argumento. Si no, incrementa cont-prg en 1.
JC ( let [ last_val ( last pila ) ,
pila ( pop pila ) ,
next_cont_prg (
cond
( true? last_val ) ( second fetched )
:else ( inc cont-prg )
)
] ( recur cod regs-de-act next_cont_prg pila mapa-regs )
)
; CAL: Llamada a una funcion. Agrega al final de regs-de-act el reg-de-act (proveniente de mapa-regs) indicado por el argumento,
; cambia cont-prg por el valor del argumento y coloca al final de la pila la direccion de retorno (el valor del argumento incrementado en 1).
CAL ( let [
argval ( second fetched ) ,
next_cont_prg argval ,
reg-act-to-add ( get mapa-regs argval ) ,
retdir ( inc argval )
]
( recur cod ( conj regs-de-act reg-act-to-add ) next_cont_prg ( conj pila retdir ) mapa-regs )
)
; RETN: Indica el retorno de la llamada a un procedimiento (no funcion). Llama recursivamente a interpretar con valores actualizados de
; regs-de-act (se elimina el ultimo de ellos), cont-prg (pasa a ser el ultimo valor en la pila) y pila (se quita de ella el nuevo cont-prg).
RETN ( recur cod ( pop regs-de-act ) ( last pila ) ( pop pila ) mapa-regs )
; CHR: Incrementa cont-prg en 1, quita de la pila dos elementos (un string y un indice), selecciona el char del string indicado por el indice y lo coloca al final de la pila.
CHR ( let [
next_cont_prg ( inc cont-prg ) ,
args ( take-last 2 pila ) ,
s ( first args ) ,
idx ( second args ) ,
ch ( nth s idx )
next_pila ( conj ( vec ( drop-last 2 pila ) ) ch ) ,
] ( recur cod regs-de-act next_cont_prg next_pila mapa-regs )
)
)
)
)
