add sub

src/rustint/core.clj

@@ -129,6 +129,11 @@
 (declare generar-format!)
 (declare interpretar)
 
+(defn -main
+  "Rust interpreter."
+  [& args]
+  (driver-loop))
+
 (defn driver-loop
    ([]
       (prn)
@@ -1881,6 +1886,83 @@
           ADD (let [res (aplicar-operador-diadico + pila)]
                    (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))
+                       (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.
+          NOT (let [
+                  res (not (last pila)),
+                  nueva_pila (assoc pila (- (count pila) 1) res)
+                ]
+                  (recur cod regs-de-act (inc cont-prg) nueva_pila mapa-regs)
+              )
+
+          ; NEG: Incrementa cont-prg en 1, quita de la pila un elemento numerico, le cambia el signo y lo coloca al final de la pila.
+          NEG (let [
+                  res (- (last pila)),
+                  nueva_pila (assoc pila (- (count pila) 1) res)
+                ]
+                  (recur cod regs-de-act (inc cont-prg) nueva_pila mapa-regs)
+              )
+
+          ; TOI: Incrementa cont-prg en 1, quita de la pila un elemento numerico, lo convierte a entero y lo coloca al final de la pila.
+          TOI (let [
+                    res (pasar-a-int (last pila)),
+                    nueva_pila (assoc pila (- (count pila) 1) res)
+                ]
+                  (recur cod regs-de-act (inc cont-prg) nueva_pila mapa-regs)
+            )
+
+          ; TOF: Incrementa cont-prg en 1, quita de la pila un elemento numerico, lo convierte a punto flotante y lo coloca al final de la pila.
+          TOF (let [
+                    res (pasar-a-float (last pila)),
+                    nueva_pila (assoc pila (- (count pila) 1) res)
+                ]
+                  (recur cod regs-de-act (inc cont-prg) nueva_pila mapa-regs)
+            )
+
+          ; EQ: Como ADD, pero calcula la operacion relacional = entre los dos valores.
+          EQ  (let [res (aplicar-operador-diadico = pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; NEQ: Como ADD, pero calcula la operacion relacional != entre los dos valores.
+          NEQ (let [res (aplicar-operador-diadico not= pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; GT:  Como ADD, pero calcula la operacion relacional > entre los dos valores.
+          GT (let [res (aplicar-operador-diadico > pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; GTE: Como ADD, pero calcula la operacion relacional >= entre los dos valores.
+          GTE (let [res (aplicar-operador-diadico >= pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; LT: Como ADD, pero calcula la operacion relacional < entre los dos valores.
+          LT (let [res (aplicar-operador-diadico < pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; LTE: Como ADD, pero calcula la operacion relacional <= entre los dos valores.
+          LTE (let [res (aplicar-operador-diadico <= pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; MOD: Como ADD, pero calcula el resto de la division.
+          MOD (let [res (aplicar-operador-diadico rem pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; DIV: Como ADD, pero divide.
+          DIV (let [res (aplicar-operador-diadico dividir pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; MUL: Como ADD, pero multiplica.
+          MUL (let [res (aplicar-operador-diadico * pila)]
+                   (if (nil? res) res (recur cod regs-de-act (inc cont-prg) res mapa-regs)))
+
+          ; 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)))
        )
   )
 )
@@ -1900,6 +1982,7 @@
 ;
 ; nil
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
 (defn flistar [ilevel t nxt]
   (cond
     (string? t) (format "\"%s\" " t)
@@ -1949,6 +2032,7 @@
         (= token (symbol "}"))
         (not= next_token (symbol "}"))
         (not= next_token (symbol ";"))
+        (not= next_token (symbol ")"))
         (> next_token_il 0)
         (not (palabra-reservada? next_token))
       )

test/rustint/core_test.clj

@@ -946,3 +946,14 @@
     ))
   )
 )
+
+(deftest test-agregar-ptocoma-main01
+  (testing "Test main 01 agregar-ptocoma"
+    (is (=
+      (agregar-ptocoma
+        (list 'fn 'main (symbol "(") (symbol ")") (symbol "{") 'println! (symbol "(") "- Hola, mundo!" (symbol ")") (symbol ";") 'print! (symbol "(") "- My name is {}, James {}. '- Hello, {}{}{}!" (symbol ",") "Bond" (symbol ",") "Bond" (symbol ",") '- '2 '+ '2 (symbol ",") '0 (symbol ",") '3 '+ '2 '* '2 (symbol ")") (symbol ";") 'println! (symbol "(") (symbol ")") (symbol ";") 'println! (symbol "(") "- Hasta la vista, Baby! I'll be back..." (symbol ")") (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'if 'true (symbol "{") "- Lo dudo! Bye!" (symbol "}") 'else (symbol "{") "- Obviamente!" (symbol "}") (symbol ")") (symbol "}"))
+      )
+        (list 'fn 'main (symbol "(") (symbol ")") (symbol "{") 'println! (symbol "(") "- Hola, mundo!" (symbol ")") (symbol ";") 'print! (symbol "(") "- My name is {}, James {}. '- Hello, {}{}{}!" (symbol ",") "Bond" (symbol ",") "Bond" (symbol ",") '- '2 '+ '2 (symbol ",") '0 (symbol ",") '3 '+ '2 '* '2 (symbol ")") (symbol ";") 'println! (symbol "(") (symbol ")") (symbol ";") 'println! (symbol "(") "- Hasta la vista, Baby! I'll be back..." (symbol ")") (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'if 'true (symbol "{") "- Lo dudo! Bye!" (symbol "}") 'else (symbol "{") "- Obviamente!" (symbol "}") (symbol ")") (symbol "}"))
+    ))
+  )
+)