reindent

* module/language/elisp/bindings.scm:
* module/language/elisp/compile-tree-il.scm:
* module/language/elisp/lexer.scm:
* module/language/elisp/parser.scm:
* module/language/elisp/runtime.scm:
* module/language/elisp/runtime/function-slot.scm:
* module/language/elisp/runtime/macro-slot.scm:
* module/language/elisp/spec.scm: Reindent.

module/language/elisp/bindings.scm

@@ -21,8 +21,10 @@
 
 (define-module (language elisp bindings)
   #:export (make-bindings
-            mark-global-needed! map-globals-needed
-            with-lexical-bindings with-dynamic-bindings
+            mark-global-needed!
+            map-globals-needed
+            with-lexical-bindings
+            with-dynamic-bindings
             get-lexical-binding))
 
 ;;; This module defines routines to handle analysis of symbol bindings
@@ -41,8 +43,7 @@
 ;;; Record type used to hold the data necessary.
 
 (define bindings-type
-  (make-record-type 'bindings
-                    '(needed-globals lexical-bindings)))
+  (make-record-type 'bindings '(needed-globals lexical-bindings)))
 
 ;;; Construct an 'empty' instance of the bindings data structure to be
 ;;; used at the start of a fresh compilation.
@@ -54,45 +55,50 @@
 ;;; slot-module.
 
 (define (mark-global-needed! bindings sym module)
-  (let* ((old-needed ((record-accessor bindings-type 'needed-globals) bindings))
+  (let* ((old-needed ((record-accessor bindings-type 'needed-globals)
+                      bindings))
          (old-in-module (or (assoc-ref old-needed module) '()))
          (new-in-module (if (memq sym old-in-module)
-                          old-in-module
-                          (cons sym old-in-module)))
+                            old-in-module
+                            (cons sym old-in-module)))
          (new-needed (assoc-set! old-needed module new-in-module)))
-    ((record-modifier bindings-type 'needed-globals) bindings new-needed)))
+    ((record-modifier bindings-type 'needed-globals)
+     bindings
+     new-needed)))
 
 ;;; Cycle through all globals needed in order to generate the code for
 ;;; their creation or some other analysis.
 
 (define (map-globals-needed bindings proc)
-  (let ((needed ((record-accessor bindings-type 'needed-globals) bindings)))
+  (let ((needed ((record-accessor bindings-type 'needed-globals)
+                 bindings)))
     (let iterate-modules ((mod-tail needed)
                           (mod-result '()))
       (if (null? mod-tail)
-        mod-result
-        (iterate-modules
-          (cdr mod-tail)
-          (let* ((aentry (car mod-tail))
-                 (module (car aentry))
-                 (symbols (cdr aentry)))
-            (let iterate-symbols ((sym-tail symbols)
-                                  (sym-result mod-result))
-              (if (null? sym-tail)
-                sym-result
-                (iterate-symbols (cdr sym-tail)
-                                 (cons (proc module (car sym-tail))
-                                       sym-result))))))))))
+          mod-result
+          (iterate-modules
+           (cdr mod-tail)
+           (let* ((aentry (car mod-tail))
+                  (module (car aentry))
+                  (symbols (cdr aentry)))
+             (let iterate-symbols ((sym-tail symbols)
+                                   (sym-result mod-result))
+               (if (null? sym-tail)
+                   sym-result
+                   (iterate-symbols (cdr sym-tail)
+                                    (cons (proc module (car sym-tail))
+                                          sym-result))))))))))
 
 ;;; Get the current lexical binding (gensym it should refer to in the
 ;;; current scope) for a symbol or #f if it is dynamically bound.
 
 (define (get-lexical-binding bindings sym)
-  (let* ((lex ((record-accessor bindings-type 'lexical-bindings) bindings))
+  (let* ((lex ((record-accessor bindings-type 'lexical-bindings)
+               bindings))
          (slot (hash-ref lex sym #f)))
     (if slot
-      (fluid-ref slot)
-      #f)))
+        (fluid-ref slot)
+        #f)))
 
 ;;; Establish a binding or mark a symbol as dynamically bound for the
 ;;; extent of calling proc.
@@ -100,25 +106,25 @@
 (define (with-symbol-bindings bindings syms targets proc)
   (if (or (not (list? syms))
           (not (and-map symbol? syms)))
-    (error "can't bind non-symbols" syms))
-  (let ((lex ((record-accessor bindings-type 'lexical-bindings) bindings)))
+      (error "can't bind non-symbols" syms))
+  (let ((lex ((record-accessor bindings-type 'lexical-bindings)
+              bindings)))
     (for-each (lambda (sym)
                 (if (not (hash-ref lex sym))
-                  (hash-set! lex sym (make-fluid))))
+                    (hash-set! lex sym (make-fluid))))
               syms)
-    (with-fluids* (map (lambda (sym)
-                         (hash-ref lex sym))
-                       syms)
+    (with-fluids* (map (lambda (sym) (hash-ref lex sym)) syms)
                   targets
                   proc)))
 
 (define (with-lexical-bindings bindings syms targets proc)
   (if (or (not (list? targets))
           (not (and-map symbol? targets)))
-    (error "invalid targets for lexical binding" targets)
-    (with-symbol-bindings bindings syms targets proc)))
+      (error "invalid targets for lexical binding" targets)
+      (with-symbol-bindings bindings syms targets proc)))
 
 (define (with-dynamic-bindings bindings syms proc)
   (with-symbol-bindings bindings
-                        syms (map (lambda (el) #f) syms)
+                        syms
+                        (map (lambda (el) #f) syms)
                         proc))