- Re-organized code-generation, and re-named it "translation".

1 files changed, 26 insertions, 26 deletions

diff --git a/new-luxc/source/luxc/generator/expression.jvm.lux b/new-luxc/source/luxc/lang/translation/expression.jvm.lux
index 798998510..af66d4994 100644
--- a/new-luxc/source/luxc/generator/expression.jvm.lux
+++ b/new-luxc/source/luxc/lang/translation/expression.jvm.lux
@@ -10,15 +10,15 @@
   (luxc ["&" base]
         (host ["$" jvm])
         (lang ["ls" synthesis]
-              [";L" variable #+ Variable Register])
-        (generator ["&;" common]
-                   ["&;" primitive]
-                   ["&;" structure]
-                   ["&;" eval]
-                   ["&;" procedure]
-                   ["&;" function]
-                   ["&;" reference]
-                   [";G" case])))
+              (translation [";T" common]
+                           [";T" primitive]
+                           [";T" structure]
+                           [";T" eval]
+                           [";T" procedure]
+                           [";T" function]
+                           [";T" reference]
+                           [";T" case])
+              [";L" variable #+ Variable Register])))
 
 (exception: #export Unrecognized-Synthesis)
 
@@ -26,7 +26,7 @@
   (-> ls;Synthesis (Meta $;Inst))
   (case synthesis
     (^code [])
-    &primitive;generate-unit
+    primitiveT;generate-unit
 
     (^code [(~ singleton)])
     (generate singleton)
@@ -34,42 +34,42 @@
     (^template [<tag> <generator>]
       [_ (<tag> value)]
       (<generator> value))
-    ([#;Bool &primitive;generate-bool]
-     [#;Nat  &primitive;generate-nat]
-     [#;Int  &primitive;generate-int]
-     [#;Deg  &primitive;generate-deg]
-     [#;Frac &primitive;generate-frac]
-     [#;Text &primitive;generate-text])
+    ([#;Bool primitiveT;generate-bool]
+     [#;Nat  primitiveT;generate-nat]
+     [#;Int  primitiveT;generate-int]
+     [#;Deg  primitiveT;generate-deg]
+     [#;Frac primitiveT;generate-frac]
+     [#;Text primitiveT;generate-text])
 
     (^code ((~ [_ (#;Nat tag)]) (~ [_ (#;Bool last?)]) (~ valueS)))
-    (&structure;generate-variant generate tag last? valueS)
+    (structureT;generate-variant generate tag last? valueS)
 
     (^code [(~@ members)])
-    (&structure;generate-tuple generate members)
+    (structureT;generate-tuple generate members)
 
     (^ [_ (#;Form (list [_ (#;Int var)]))])
     (if (variableL;captured? var)
-      (&reference;generate-captured var)
-      (&reference;generate-variable var))
+      (referenceT;generate-captured var)
+      (referenceT;generate-variable var))
 
     [_ (#;Symbol definition)]
-    (&reference;generate-definition definition)
+    (referenceT;generate-definition definition)
 
     (^code ("lux let" (~ [_ (#;Nat register)]) (~ inputS) (~ exprS)))
-    (caseG;generate-let generate register inputS exprS)
+    (caseT;generate-let generate register inputS exprS)
 
     (^code ("lux case" (~ inputS) (~ pathPS)))
-    (caseG;generate-case generate inputS pathPS)
+    (caseT;generate-case generate inputS pathPS)
 
     (^multi (^code ("lux function" (~ [_ (#;Nat arity)]) [(~@ environment)] (~ bodyS)))
             [(s;run environment (p;some s;int)) (#e;Success environment)])
-    (&function;generate-function generate environment arity bodyS)
+    (functionT;generate-function generate environment arity bodyS)
 
     (^code ("lux call" (~ functionS) (~@ argsS)))
-    (&function;generate-call generate functionS argsS)
+    (functionT;generate-call generate functionS argsS)
 
     (^code ((~ [_ (#;Text procedure)]) (~@ argsS)))
-    (&procedure;generate-procedure generate procedure argsS)
+    (procedureT;generate-procedure generate procedure argsS)
 
     _
     (&;throw Unrecognized-Synthesis (%code synthesis))