From 26c92e9a484d4308ea14ef94a25a52fdfc319001 Mon Sep 17 00:00:00 2001
From: Simon Forman <sforman@hushmail.com>
Date: Tue, 28 Jan 2020 18:04:51 -0800
Subject: [PATCH] Add assoc to kinda sorta track the values in the registers.

But it doesn't update e.g. if you add two numbers, the value int(N) stays the same.

It could be modified to track the value as it computes?  But then why keep them in registers at all? Sometimes a value must arrive at runtime, eh?
---
 thun/thun.pl | 53 +++++++++++++++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 21 deletions(-)

diff --git a/thun/thun.pl b/thun/thun.pl
index ffd8857..9484c01 100644
--- a/thun/thun.pl
+++ b/thun/thun.pl
@@ -652,54 +652,62 @@ and then checking if a register is ready for reclaimation is just
 member/3.  Or you can just keep a reference count for each register...
 Would it be useful to put CLP(FD) constraints on the ref counts?
 
-reggy(FreePool, References)
+reggy(FreePool, References, ValueMap)
 
 */
 
+encode_list(List, FP, FP, Addr) --> [],
+    {addr(list(List))=Addr}.
+
 appears_only_once(Term, List) :- append(_, [Term|Tail], List), !, \+ member(Term, Tail).
 
-reg_used_once(Reg, reggy(_, References)) :- appears_only_once(Reg, References).
+reg_used_once(Reg, reggy(_, References, _)) :- appears_only_once(Reg, References).
 
 get_reggy([], _, _) :- writeln('Out of Registers'), fail.
 get_reggy([Reg|FreePool], Reg, FreePool).
 
-get_reg(Reg, reggy(FreePool0, References), reggy(FreePool, [Reg|References])) --> [],
+get_reg(Reg, reggy(FreePool0, References, V), reggy(FreePool, [Reg|References], V)) --> [],
     {get_reggy(FreePool0, Reg, FreePool)}.
 
-free_reg(Reg, reggy(FreePool0, References0), reggy(FreePool, References)) --> [],
+free_reg(Reg, reggy(FreePool0, References0, V0), reggy(FreePool, References, V)) --> [],
     { select(Reg, References0, References),
     (  member(Reg, References)  % If reg is still in use
     -> FreePool=     FreePool0  % we can't free it yet
-    ;  FreePool=[Reg|FreePool0] % otherwise we put it back in the pool.
+    ;  FreePool=[Reg|FreePool0], % otherwise we put it back in the pool.
+       del_assoc(Reg, V0, _, V)
     )}.
 
-add_ref(Reg, reggy(FreePool, References), reggy(FreePool, [Reg|References])) --> [].
+add_ref(Reg, reggy(FreePool, References, V), reggy(FreePool, [Reg|References], V)) --> [].
 
-assoc_reg(_, _, _) --> [].
+assoc_reg(Reg, Value, reggy(FreePool, References, V0), reggy(FreePool, References, V)) --> [],
+    {put_assoc(Reg, V0, Value, V)}.
 
-thun_compile(E, Si, So) -->
-    {FP=reggy([r0, r1, r2, r3,
+thun_compile(E, Si, So, FP) -->
+    {empty_assoc(V),
+     FP0=reggy([r0, r1, r2, r3,
                r4, r5, r6, r7,
                r8, r9, rA, rB,
-               rC, rD, rE, rF], [])},
-    thun_compile(E, Si, So, FP, _).
+               rC, rD, rE, rF], [], V)},
+    thun_compile(E, Si, So, FP0, FP).
 
 thun_compile([], S, S, FP, FP) --> [].
 thun_compile([Term|Rest], Si, So, FP0, FP1) --> thun_compile(Term, Rest, Si, So, FP0, FP1).
 
 thun_compile(int(I), E, Si, So, FP0, FP) -->
     [mov_imm(R, int(I))],
-    get_reg(R, FP0, FP1), assoc_reg(R, int(I), _),
-    thun_compile(E, [R|Si], So, FP1, FP).
+    get_reg(R, FP0, FP1), assoc_reg(R, int(I), FP1, FP2),
+    thun_compile(E, [R|Si], So, FP2, FP).
 
 thun_compile(bool(B), E, Si, So, FP0, FP) -->
-    get_reg(R, FP0, FP1), assoc_reg(R, bool(B), _),
-    thun_compile(E, [R|Si], So, FP1, FP).
+    get_reg(R, FP0, FP1), assoc_reg(R, bool(B), FP1, FP2),
+    thun_compile(E, [R|Si], So, FP2, FP).
 
 thun_compile(list(L), E, Si, So, FP0, FP) -->
-    % encode_list(_), ???
-    get_reg(R, FP0, FP1), assoc_reg(R, list(L), _),
-    thun_compile(E, [R|Si], So, FP1, FP).
+    encode_list(L, FP0, FP1, Addr),
+    get_reg(R, FP1, FP2),
+    [load_imm(R, Addr)],
+    assoc_reg(R, Addr, FP2, FP3),
+    thun_compile(E, [R|Si], So, FP3, FP).
 
 thun_compile(symbol(Name), E, Si, So, FP0, FP) -->   {def(Name, _)}, !,         def_compile(Name, E, Si, So, FP0, FP).
 thun_compile(symbol(Name), E, Si, So, FP0, FP) -->  {func(Name, _, _)}, !,     func_compile(Name, E, Si, So, FP0, FP).
@@ -725,6 +733,7 @@ func_compile(+, E, [A, B|S], So, FP0, FP) --> !,
       free_reg(B, FP2, FP3),
       {Si=[R|S]}
     ),
+    % Update value in the context?
     thun_compile(E, Si, So, FP3, FP).
 
 func_compile(dup, E, [A|S], So, FP0, FP) --> !,
@@ -751,13 +760,15 @@ combo_compile(_Combo, E, Si, So, FP0, FP) -->
 
 compiler(InputString, MachineCode, StackIn, StackOut) :-
     phrase(joy_parse(Expression), InputString), !,
-    phrase(thun_compile(Expression, StackIn, StackOut), MachineCode, []).
+    phrase(thun_compile(Expression, StackIn, StackOut, _), MachineCode, []).
 
 
 show_compiler(InputString, StackIn, StackOut) :-
     phrase(joy_parse(Expression), InputString), !,
-    phrase(thun_compile(Expression, StackIn, StackOut), MachineCode, []),
-    maplist(portray_clause, MachineCode).
+    phrase(thun_compile(Expression, StackIn, StackOut, reggy(_, _, V)), MachineCode, []),
+    maplist(portray_clause, MachineCode),
+    assoc_to_list(V, VP),
+    portray_clause(VP).
 
 
 /*