crossnox
/
7514-rust-interpreter-in-clojure
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Compare commits

base: crossnox:2c39d070a6c77ee64b2d487bb3527295108debd2
Branches Tags
crossnox:master
...
compare: crossnox:6f8b9235ec3a162e2f400594273e2302ec5f0109
Branches Tags
crossnox:master

16 Commits
2c39d070a6 ... 6f8b9235ec

Author SHA1 Message Date
CrossNox 6f8b9235ec fix code
3 years ago
CrossNox caba5c6fbe hardcode value
3 years ago
CrossNox 7cef7f6bff add test
3 years ago
CrossNox 7ebc27abd1 smallest code to make test pass
3 years ago
CrossNox 3a7b475823 add test for generar ref
3 years ago
CrossNox 7da79b695f fix code
3 years ago
CrossNox c0909104eb fix test
3 years ago
CrossNox 8de1cadcbf new test
3 years ago
CrossNox 5dd92c24f0 smalles code change for test to pass
3 years ago
CrossNox 3c0cf83885 add test for fixup
3 years ago
CrossNox e87f60853c add test
3 years ago
CrossNox 0fb01aeabd fix code
3 years ago
CrossNox 298ec76368 add test
3 years ago
CrossNox 711a91f475 add another test
3 years ago
CrossNox 25a33d1ec3 fix code
3 years ago
CrossNox 7ad9057f35 add test
3 years ago
2 changed files with 180 additions and 16 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats
  1. 50
      src/rustint/core.clj
  2. 146
      test/rustint/core_test.clj

50
src/rustint/core.clj
Unescape View File

@ -2214,10 +2214,25 @@
; [) (; println! ( "{}" , v ) ; }) [fn inc ( v : & mut i64 ) { * v += 1 ; } fn main ( ) { let mut v : i64 = 5 ; inc ( & mut v] :sin-errores [[0 2] [[inc [fn [([v : & mut i64]) ()]] 2] [main [fn [() ()]] 6] [v [var-mut i64] 0]]] 1 [[CAL 6] HLT [POPARG 0] [PUSHFI 1] [POPADDREF 0] RETN [PUSHFI 5] [POP 0] [PUSHADDR 0]] [[2 [i64 nil]] [6 [i64 nil]]]]
; ^ ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; TODO
;(defn generar-ref
;
;)
(defn get-val-ult-var [ult-var ctx]
(let [
matches (filter #(= ult-var (get %1 0)) (get ctx 1)),
last_match (last matches)
] (get last_match 2)
)
)
(defn generar-ref [amb]
(cond
(not= (estado amb) :sin-errores) amb
:else (let [
ult-var (last (simb-ya-parseados amb)),
val-ult-var (get-val-ult-var ult-var (contexto amb))
]
(generar amb 'PUSHADDR val-ult-var)
)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; FIXUP: Recibe un ambiente y la ubicacion de un JMP ? a corregir en el vector de bytecode. Si el estado no es
@ -2231,10 +2246,15 @@
; [{ (x = 20 ; } ; println! ( "{}" , x ) }) [fn main ( ) { let x : i64 ; if false { x = 10 ; } else] :sin-errores [[0 1 2] [[main [fn [() ()]] 2] [x [var-inmut i64] 0]]] 1 [[CAL 2] HLT [PUSHFI false] [JC 5] [JMP 8] [PUSHFI 10] [POP 0] [JMP ?]] [[2 [i64 nil]]]]
; ^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^: tamano 8 ^ ubicacion de JMP ? en contexto
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; TODO
; (defn fixup
;
;)
(defn fixup [amb jmploc]
(cond
(not= (get amb 3) :sin-errores) amb
:else (
let [bytecode (get amb 6)]
(assoc-in amb [6 jmploc 1] (count bytecode))
)
)
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CONVERTIR-FORMATO-IMPRESION: Recibe una lista con los argumentos de print! de Rust y devuelve una lista con los
@ -2412,10 +2432,9 @@
; [[[String "2"] [i64 6] [i64 2] [i64 3] [i64 0]] [[f64 3] [i64 0]]]
; ^^^ ^
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; TODO
; (defn cargar-en-ult-reg
;
;)
(defn cargar-en-ult-reg [reg-act dir rtype value]
(assoc-in reg-act [(- (count reg-act) 1) dir] [rtype value])
)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; CARGAR-EN-REG-DEST: Recibe un vector de registros de activacion, coordenadas, un tipo y un valor. Devuelve el
@ -2430,9 +2449,8 @@
; [[[String "2"] [i64 6] [i64 2] [f64 3] [i64 0]] [[i64 6] [i64 2] [i64 [0 3]] [i64 [0 4]] [i64 2] [i64 2]]]
; ^^^ ^
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; TODO
;(defn cargar-en-reg-dest
;
;)
(defn cargar-en-reg-dest [reg-act coords rtype value]
(assoc-in reg-act coords [rtype value])
)
true

146
test/rustint/core_test.clj
Unescape View File

@ -789,3 +789,149 @@
))
)
)
(deftest test-cargar-en-reg-dest-01
(testing "Test 01 cargar-en-reg-dest"
(is (=
(cargar-en-reg-dest [[['String "2"] ['i64 6] ['i64 2] ['i64 2] ['i64 2]] [['i64 6] ['i64 2] ['i64 [0 3]] ['i64 [0 4]] ['i64 2] ['i64 2]]] [0 4] 'i64 0)
[[['String "2"] ['i64 6] ['i64 2] ['i64 2] ['i64 0]] [['i64 6] ['i64 2] ['i64 [0 3]] ['i64 [0 4]] ['i64 2] ['i64 2]]]
))
)
)
(deftest test-cargar-en-reg-dest-02
(testing "Test 02 cargar-en-reg-dest"
(is (=
(cargar-en-reg-dest [[['String "2"] ['i64 6] ['i64 2] ['i64 2] ['i64 0]] [['i64 6] ['i64 2] ['i64 [0 3]] ['i64 [0 4]] ['i64 2] ['i64 2]]] [0 3] 'f64 3)
[[['String "2"] ['i64 6] ['i64 2] ['f64 3] ['i64 0]] [['i64 6] ['i64 2] ['i64 [0 3]] ['i64 [0 4]] ['i64 2] ['i64 2]]]
))
)
)
(deftest test-cargar-en-ult-reg-01
(testing "Test 01 cargar-en-ult-reg"
(is (=
(cargar-en-ult-reg [[['String "2"] ['i64 6] ['i64 2] ['i64 3] ['i64 0]] [['i64 nil] ['i64 nil]]] 1 'i64 0)
[[['String "2"] ['i64 6] ['i64 2] ['i64 3] ['i64 0]] [['i64 nil] ['i64 0]]]
))
)
)
(deftest test-cargar-en-ult-reg-02
(testing "Test 02 cargar-en-ult-reg"
(is (=
(cargar-en-ult-reg [[['String "2"] ['i64 6] ['i64 2] ['i64 3] ['i64 0]] [['i64 nil] ['i64 0]]] 0 'f64 3)
[[['String "2"] ['i64 6] ['i64 2] ['i64 3] ['i64 0]] [['f64 3] ['i64 0]]]
))
)
)
(deftest test-fixup-01
(testing "Test 01 fixup"
(is (=
(fixup [
(symbol "{")
(list 'x '= 20 (symbol ";") (symbol "}") (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'x (symbol ")") (symbol "}"))
['fn 'main (symbol "(") (symbol ")") (symbol "{") 'let 'x (symbol ":") 'i64 (symbol ";") 'if false (symbol "{") 'x '= 10 (symbol ";") (symbol "}") 'else]
8
[[0 1 2] [['main ['fn [() ()]] 2] ['x ['var-inmut 'i64] 0]]]
1
[['CAL 2] 'HLT ['PUSHFI false] ['JC 5] ['JMP '?] ['PUSHFI 10] ['POP 0] ['JMP '?]]
[[2 ['i64 nil]]]
] 4)
[
(symbol "{")
(list 'x '= 20 (symbol ";") (symbol "}") (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'x (symbol ")") (symbol "}"))
['fn 'main (symbol "(") (symbol ")") (symbol "{") 'let 'x (symbol ":") 'i64 (symbol ";") 'if false (symbol "{") 'x '= 10 (symbol ";") (symbol "}") 'else]
8
[[0 1 2] [['main ['fn [() ()]] 2] ['x ['var-inmut 'i64] 0]]]
1
[['CAL 2] 'HLT ['PUSHFI false] ['JC 5] ['JMP '?] ['PUSHFI 10] ['POP 0] ['JMP '?]]
[[2 ['i64 nil]]]
]
))
)
)
(deftest test-fixup-02
(testing "Test 02 fixup"
(is (=
(fixup [
(symbol "{")
(list 'x '= 20 (symbol ";") (symbol "}") (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'x (symbol ")") (symbol "}"))
['fn 'main (symbol "(") (symbol ")") (symbol "{") 'let 'x (symbol ":") 'i64 (symbol ";") 'if false (symbol "{") 'x '= 10 (symbol ";") (symbol "}") 'else]
:sin-errores
[[0 1 2] [['main ['fn [() ()]] 2] ['x ['var-inmut 'i64] 0]]]
1
[['CAL 2] 'HLT ['PUSHFI false] ['JC 5] ['JMP '?] ['PUSHFI 10] ['POP 0] ['JMP '?]]
[[2 ['i64 nil]]]
] 4)
[
(symbol "{")
(list 'x '= 20 (symbol ";") (symbol "}") (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'x (symbol ")") (symbol "}"))
['fn 'main (symbol "(") (symbol ")") (symbol "{") 'let 'x (symbol ":") 'i64 (symbol ";") 'if false (symbol "{") 'x '= 10 (symbol ";") (symbol "}") 'else]
:sin-errores
[[0 1 2] [['main ['fn [() ()]] 2] ['x ['var-inmut 'i64] 0]]]
1
[['CAL 2] 'HLT ['PUSHFI false] ['JC 5] ['JMP 8] ['PUSHFI 10] ['POP 0] ['JMP '?]]
[[2 ['i64 nil]]]
]
))
)
)
(deftest test-generar-ref-01
(testing "Test 01 generar ref"
(is (=
(generar-ref [
(symbol ")")
(list (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'v (symbol ")") (symbol ";") (symbol "}"))
['fn 'inc (symbol "(") 'v (symbol ":") (symbol "&") 'mut 'i64 (symbol ")") (symbol "{") '* 'v (symbol "+=") 1 (symbol ";") (symbol "}") 'fn 'main (symbol "(") (symbol ")") (symbol "{") 'let 'mut 'v (symbol ":") 'i64 (symbol "=") 5 (symbol ";") 'inc (symbol "(") (symbol "&") 'mut 'v]
8
[[0 2] [['inc ['fn [(list ['v (symbol ":") (symbol "&") 'mut 'i64]) ()]] 2] ['main ['fn [() ()]] 6] ['v ['var-mut 'i64] 0]]]
1
[['CAL 6] 'HLT ['POPARG 0] ['PUSHFI 1] ['POPADDREF 0] 'RETN ['PUSHFI 5] ['POP 0]]
[[2 ['i64 nil]] [6 ['i64 nil]]]
])
[
(symbol")")
(list (symbol ";") 'println! (symbol"(") "{}" (symbol ",") 'v (symbol ")") (symbol ";") (symbol "}"))
['fn 'inc (symbol "(") 'v (symbol ":") (symbol "&") 'mut 'i64 (symbol ")") (symbol "{") '* 'v (symbol "+=") 1 (symbol ";") (symbol "}") 'fn 'main (symbol "(") (symbol ")") (symbol "{") 'let 'mut 'v (symbol ":") 'i64 (symbol "=") 5 (symbol ";") 'inc (symbol "(") (symbol "&") 'mut 'v]
8
[[0 2] [['inc ['fn [(list ['v (symbol ":") (symbol "&") 'mut 'i64]) ()]] 2] ['main ['fn [() ()]] 6] ['v ['var-mut 'i64] 0]]]
1
[['CAL 6] 'HLT ['POPARG 0] ['PUSHFI 1] ['POPADDREF 0] 'RETN ['PUSHFI 5] ['POP 0]]
[[2 ['i64 nil]] [6 ['i64 nil]]]
]
))
)
)
(deftest test-generar-ref-02
(testing "Test 02 generar ref"
(is (=
(generar-ref
[
(symbol ")")
(list (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'v (symbol ")") (symbol ";") (symbol "}"))
['fn 'inc (symbol "(") 'v (symbol ":") (symbol "&") 'mut 'i64 (symbol ")") (symbol "{") '* 'v (symbol "+=") 1 (symbol ";") (symbol "}") 'fn 'main (symbol "(") (symbol ")") (symbol "{") 'let 'mut 'v (symbol ":") 'i64 (symbol "=") 5 (symbol ";") 'inc (symbol "(") (symbol "&") 'mut 'v]
:sin-errores
[[0 2] [['inc ['fn [(list ['v (symbol ":") (symbol "&") 'mut 'i64]) ()]] 2] ['main ['fn [() ()]] 6] ['v ['var-mut 'i64] 0]]]
1
[['CAL 6] 'HLT ['POPARG 0] ['PUSHFI 1] ['POPADDREF 0] 'RETN ['PUSHFI 5] ['POP 0]]
[[2 ['i64 nil]] [6 ['i64 nil]]]
]
)
[
(symbol ")")
(list (symbol ";") 'println! (symbol "(") "{}" (symbol ",") 'v (symbol ")") (symbol ";") (symbol "}"))
['fn 'inc (symbol "(") 'v (symbol ":") (symbol "&") 'mut 'i64 (symbol ")") (symbol "{") '* 'v (symbol "+=") 1 (symbol ";") (symbol "}") 'fn 'main (symbol "(") (symbol ")") (symbol "{") 'let 'mut 'v (symbol ":") 'i64 (symbol "=") 5 (symbol ";") 'inc (symbol "(") (symbol "&") 'mut 'v]
:sin-errores
[[0 2] [['inc ['fn [(list ['v (symbol ":") (symbol "&") 'mut 'i64]) ()]] 2] ['main ['fn [() ()]] 6] ['v ['var-mut 'i64] 0]]]
1
[['CAL 6] 'HLT ['POPARG 0] ['PUSHFI 1] ['POPADDREF 0] 'RETN ['PUSHFI 5] ['POP 0] ['PUSHADDR 0]]
[[2 ['i64 nil]] [6 ['i64 nil]]]
]
))
)
)

Write Preview
Loading…
Cancel
Save