shithub: sl

--- a/boot/sl.boot

+++ b/boot/sl.boot

@@ -170,7 +170,7 @@

             #fn("n10<==:" #() cddar) cdddar #fn("n10<===:" #() cdddar) cddddr

             #fn("n10====:" #() cddddr) cdddr #fn("n10===:" #() cdddr) cddr

             #fn("n10==:" #() cddr) closure? #fn("n10\\;36040[S:" #() closure?) compile

-            #fn("n170q7105162:" #(compile-f lower-define) compile) compile-and #fn("n570018283D218467:" #(compile-short-circuit

+            #fn("n170q7105162:" #(compile-f lower-def) compile) compile-and #fn("n570018283D218467:" #(compile-short-circuit

   brn) compile-and)

             compile-app #fn("n483<88R3U07088152JK088Z3E0218851[3;0218851@40887283=23523q07401q895440r40r4GKMp4750183=530r40r4G8:UMp47608237027@40288:63:89[;3904798951892:Cf07089152J\\0212:517:d3P07;83r2523E07401q83T5447602:62:89B3N089<2<CF07=83513=07>01828364:8:360q@F07401q895440r40r4GKMp4750183=530r40r4G8;UMp48:360q@=00r40r4Gr/Mp48:3C07?018283898:8;67:760823702@@402A8;63:" #(in-env?

   #fn(top-level-value) length> 255 compile-in compile-arglist emit tcall.l call.l

@@ -218,7 +218,7 @@

             compile-sym #fn("n470821E538821C`02282513M073248251513@07502624825163:750278263:88<El23W0750287988=51534833A088=T3:07502:62:q:7502;7<08252534833A088=T3:07502:62:q:" #(lookup-sym

   global #fn(const?) printable? #fn(top-level-value) emit loadv loadg loada vinfo:index car loadc

   capture-var!) compile-sym)

-            compile-thunk #fn("n170q21q72051e362:" #(compile-f λ lower-define) compile-thunk)

+            compile-thunk #fn("n170q21q72051e362:" #(compile-f λ lower-def) compile-thunk)

             compile-while #fn("n4205020507101q72505440r40r4GKMp473024885347101q825447302589534730265240r40r4Gr/Mp47101q835447302788534730248963:" #(#fn(gensym)

   compile-in void emit label brn pop jmp) compile-while)

             complex-bindings #fn("n2205020507101qq8687564722386>174875162:" #(#fn(table)

@@ -259,9 +259,9 @@

   #fn(io->str)) encode-byte-code)

             error #fn("z020210P61:" #(#fn(raise) error) error) eval

             #fn("n170710515160:" #(compile-thunk macroexpand) eval) even? #fn("n1200K52El2:" #(#fn(logand)) even?)

-            every #fn("n21H;JD0401<51;3:047001=62:" #(every) every) expand-define

-            #fn("n10T70051B3:070051@H085R37021@=07223740515285R3@021258586<e3e2:212585<2627e185=e128865185<54e3e2:" #(cddr

-  #1# error "compile error: invalid syntax " print-to-str set! #fn(nconc) λ #fn(copy-list)) expand-define)

+            every #fn("n21H;JD0401<51;3:047001=62:" #(every) every) expand-def

+            #fn("n10T70051B3:070051@H085R37021@=07223740515285R3<0258586<e3:2585<2627e185=e128865185<54e3:" #(cddr

+  #1# error "compile error: invalid syntax " print-to-str set! #fn(nconc) λ #fn(copy-list)) expand-def)

             extend-env #fn("n370182E530P:" #(vars-to-env) extend-env) filter

             #fn("n2I20210>1?65148601qe163:" #(#0# #fn("n382I1B3Q04A1<513?0821<qPN=?2@30q41=?1@\x0e/4=:" #() filter-)) filter)

             find #fn("O200050007000W2000J7071?24W3000J7072?34W4000J60E?44W5000J60q?54W6000J60q?647324830>2125822684278528866::" #(#(:key

@@ -329,10 +329,10 @@

                                                                            #fn(raise) load-error))) load)

             load-process #fn("n170061:" #(eval) load-process) lookup-sym

             #fn("n31J5020:1<2108752883808288P:7201=82KM63:" #(global #fn(assq) lookup-sym) lookup-sym)

-            lower-define #fn("n1I2021?55140H;J804720513400:0<23C<0747505161:0<26CK02726e10Te185051e17805164:2974062:" #(#1#

+            lower-def #fn("n1I2021?55140H;J804720513400:0<23C@024757605151e2:0<27CK02827e10Te185051e17905164:2:75062:" #(#0#

   #fn("n170051B3N071051B3=02270051P@7073051@607450758551768551863D0278687e328748652P:87:" #(cddr

-  cdddr begin caddr void get-defined-vars lower-define λ #fn(map)) λ-body) quoted? def lower-define

-  expand-define λ #fn(nconc) lastcdr #fn(map)) lower-define)

+  cdddr begin caddr void get-defined-vars lower-def λ #fn(map)) λ-body) quoted? def #1# lower-def

+  expand-def λ #fn(nconc) lastcdr #fn(map)) lower-def)

             macrocall? #fn("n10<R;3904700<61:" #(get-syntax) macrocall?) macroexpand

             #fn("n1IIIIIIIIIIIb5b6b7b8b9b:b;b<b=b>b?208521_51420862286>1_514208723e1_51420882485868?87>4_5142089258?89>2_514208:268:>1_514208;278:8988>3_514208<288?8:8988>4_514208=29888?>2_514208>2:_514208?2;8?8>8;8<8=>5_5148?<0q62:" #(#0#

   #fn("n20Z;J904200152S:" #(#fn(assq)) top?) #fn("n10H3400:020d3400:0<B3P07105122CF023A<7405151A<0=5162:0<A<0=51P:" #(((begin))

--- a/src/compiler.sl

+++ b/src/compiler.sl

@@ -576,10 +576,10 @@

       (mark-label g nxt)

       (emit-optional-arg-inits g env (cdr opta) vars (+ i 1)))))

-;; define

+;; def

-(def (expand-define x)

-  ;; expand a single `define` expression to `set!`

+(def (expand-def x)

+  ;; expand a single `def` expression to `set!`

   (let* ((form (cadr x))

          (body (if (cons? (cddr x))

                    (cddr x)

@@ -587,9 +587,9 @@

                        #.void

                        (error "compile error: invalid syntax " (print-to-str x))))))

     (if (sym? form)

-        `(#.void (set! ,form ,(car body)))

-        `(#.void (set! ,(car form)

-               (λ ,(cdr form) ,@body . ,(car form)))))))

+        `(set! ,form ,(car body))

+        `(set! ,(car form)

+               (λ ,(cdr form) ,@body . ,(car form))))))

 (def get-defined-vars

   (letrec ((get-defined-vars-

@@ -607,7 +607,7 @@

                     (else NIL)))))

     (λ (expr) (delete-duplicates (get-defined-vars- expr)))))

-(def (lower-define e)

+(def (lower-def e)

   ;; convert lambda to one body expression and process internal defines

   (def (λ-body e)

     (let* ((B (if (cons? (cddr e))

@@ -616,7 +616,7 @@

                       (caddr e))

                   (void)))

            (V (get-defined-vars B))

-           (new-B (lower-define B)))

+           (new-B (lower-def B)))

       (if V

           (cons `(λ ,V ,new-B)

                 (map void V))

@@ -624,11 +624,11 @@

   (cond ((or (atom? e) (quoted? e))

e)

         ((eq? (car e) 'def)

-         (lower-define (expand-define e)))

+         `(#.void ,(lower-def (expand-def e))))

         ((eq? (car e) 'λ)

          `(λ ,(cadr e) ,(λ-body e) . ,(lastcdr e)))

         (else

-         (map lower-define e))))

+         (map lower-def e))))

 ;; closure analysis

@@ -681,11 +681,12 @@

 ;; main entry points

-(def (compile f) (compile-f NIL (lower-define f)))

+(def (compile f)

+  (compile-f NIL (lower-def f)))

 (def (compile-thunk expr)

   ;; to eval a top-level expression we need to avoid internal define

-  (compile-f NIL `(λ () ,(lower-define expr))))

+  (compile-f NIL `(λ () ,(lower-def expr))))

 (def (compile-f env f)

   (receive (ff ignore)