(ice-9 safe-r5rs) fixes for bound aux syntax

* module/ice-9/safe-r5rs.scm: Define local versions of `case' and `cond'
  that assume aux syntax is unbound.  If this doesn't work, we can
  switch to exporting aux syntax.
* module/ice-9/top-repl.scm (top-repl): Don't add (ice-9 r5rs) to the
  REPL environment.

module/ice-9/safe-r5rs.scm

@@ -1,4 +1,5 @@
-;;;; 	Copyright (C) 2000, 2001, 2004, 2006, 2010 Free Software Foundation, Inc.
+;;;; Copyright (C) 2000-2001,2004,2006,2008-2010,2019
+;;;;   Free Software Foundation, Inc.
 ;;;;
 ;;;; This library is free software; you can redistribute it and/or
 ;;;; modify it under the terms of the GNU Lesser General Public
@@ -18,128 +19,214 @@
 ;;;; Safe subset of R5RS bindings
 
 (define-module (ice-9 safe-r5rs)
-  :re-export (eqv? eq? equal?
+  #:pure
-	      number?	complex? real? rational? integer?
+  #:use-module ((guile) #:hide (case cond syntax-rules _ => else ...))
-	      exact? inexact?
+  #:use-module (ice-9 ports)
-	      = < > <= >=
+  #:use-module ((guile) #:select ((_ . ^_)
-	      zero? positive?	negative? odd? even?
+                                  (... . ^...)))
-	      max min
+  #:re-export (quote
-	      + * - /
+               quasiquote
-	      abs
+               unquote unquote-splicing
-	      quotient remainder modulo
+               define-syntax let-syntax letrec-syntax
-	      gcd lcm
+               define lambda let let* letrec begin do
-	      numerator denominator
+               if set! delay and or
-	      rationalize
-	      floor ceiling truncate round
-	      exp log sin cos tan asin acos atan
-	      sqrt
-	      expt
-	      make-rectangular make-polar real-part imag-part magnitude angle
-	      exact->inexact inexact->exact
 
-	      number->string string->number
+               eqv? eq? equal?
+               number? complex? real? rational? integer?
+               exact? inexact?
+               = < > <= >=
+               zero? positive? negative? odd? even?
+               max min
+               + * - /
+               abs
+               quotient remainder modulo
+               gcd lcm
+               numerator denominator
+               rationalize
+               floor ceiling truncate round
+               exp log sin cos tan asin acos atan
+               sqrt
+               expt
+               make-rectangular make-polar real-part imag-part magnitude angle
+               exact->inexact inexact->exact
 
-	      boolean?
+               number->string string->number
-	      not
 
-	      pair?
+               boolean?
-	      cons car cdr
+               not
-	      set-car! set-cdr!
-	      caar cadr cdar cddr
-	      caaar caadr cadar caddr cdaar cdadr cddar cdddr
-	      caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
-	      cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
-	      null?
-	      list?
-	      list
-	      length
-	      append
-	      reverse
-	      list-tail list-ref
-	      memq memv member
-	      assq assv assoc
 
-	      symbol?
+               pair?
-	      symbol->string string->symbol
+               cons car cdr
+               set-car! set-cdr!
+               caar cadr cdar cddr
+               caaar caadr cadar caddr cdaar cdadr cddar cdddr
+               caaaar caaadr caadar caaddr cadaar cadadr caddar cadddr
+               cdaaar cdaadr cdadar cdaddr cddaar cddadr cdddar cddddr
+               null?
+               list?
+               list
+               length
+               append
+               reverse
+               list-tail list-ref
+               memq memv member
+               assq assv assoc
 
-	      char?
+               symbol?
-	      char=? char<? char>? char<=? char>=?
+               symbol->string string->symbol
-	      char-ci=? char-ci<? char-ci>? char-ci<=? char-ci>=?
-	      char-alphabetic? char-numeric? char-whitespace?
-	      char-upper-case? char-lower-case?
-	      char->integer integer->char
-	      char-upcase
-	      char-downcase
 
-	      string?
+               char?
-	      make-string
+               char=? char<? char>? char<=? char>=?
-	      string
+               char-ci=? char-ci<? char-ci>? char-ci<=? char-ci>=?
-	      string-length
+               char-alphabetic? char-numeric? char-whitespace?
-	      string-ref string-set!
+               char-upper-case? char-lower-case?
-	      string=? string-ci=?
+               char->integer integer->char
-	      string<? string>? string<=? string>=?
+               char-upcase
-	      string-ci<? string-ci>? string-ci<=? string-ci>=?
+               char-downcase
-	      substring
-	      string-length
-	      string-append
-	      string->list list->string
-	      string-copy string-fill!
 
-	      vector?
+               string?
-	      make-vector
+               make-string
-	      vector
+               string
-	      vector-length
+               string-length
-	      vector-ref vector-set!
+               string-ref string-set!
-	      vector->list list->vector
+               string=? string-ci=?
-	      vector-fill!
+               string<? string>? string<=? string>=?
+               string-ci<? string-ci>? string-ci<=? string-ci>=?
+               substring
+               string-length
+               string-append
+               string->list list->string
+               string-copy string-fill!
 
-	      procedure?
+               vector?
-	      apply
+               make-vector
-	      map
+               vector
-	      for-each
+               vector-length
-	      force
+               vector-ref vector-set!
+               vector->list list->vector
+               vector-fill!
 
-	      call-with-current-continuation
+               procedure?
+               apply
+               map
+               for-each
+               force
 
-	      values
+               call-with-current-continuation
-	      call-with-values
-	      dynamic-wind
 
-	      eval
+               values
+               call-with-values
+               dynamic-wind
 
-	      input-port? output-port?
+               eval
-	      current-input-port current-output-port
 
-	      read
+               input-port? output-port?
-	      read-char
+               current-input-port current-output-port
-	      peek-char
-	      eof-object?
-	      char-ready?
 
-	      write
+               read
-	      display
+               read-char
-	      newline
+               peek-char
-	      write-char
+               eof-object?
+               char-ready?
 
-	      ;;transcript-on
+               write
-	      ;;transcript-off
+               display
-	      )
+               newline
+               write-char
 
-  :export (null-environment))
+               ;;transcript-on
+               ;;transcript-off
+               )
 
-(define null-interface (resolve-interface '(ice-9 null)))
+  #:export (null-environment
+            syntax-rules cond case))
 
-(module-use! (module-public-interface (current-module))
+;;; These definitions of `cond', `case', and `syntax-rules' differ from
-             null-interface)
+;;; the ones in Guile in that they expect their auxiliary syntax (`_',
+;;; `...', `else', and `=>') to be unbound.  They also don't support
+;;; some extensions from Guile (e.g. `=>' in `case'.).
+
+(define-syntax syntax-rules
+  (lambda (x)
+    (define (replace-underscores pattern)
+      (syntax-case pattern (_)
+        (_ #'^_)
+        ((x . y)
+         (with-syntax ((x (replace-underscores #'x))
+                       (y (replace-underscores #'y)))
+           #'(x . y)))
+        ((x . y)
+         (with-syntax ((x (replace-underscores #'x))
+                       (y (replace-underscores #'y)))
+           #'(x . y)))
+        (#(x ^...)
+         (with-syntax (((x ^...) (map replace-underscores #'(x ^...))))
+           #'#(x ^...)))
+        (x #'x)))
+    (syntax-case x ()
+      ((^_ dots (k ^...) . clauses)
+       (identifier? #'dots)
+       #'(with-ellipsis dots (syntax-rules (k ^...) . clauses)))
+      ((^_ (k ^...) ((keyword . pattern) template) ^...)
+       (with-syntax (((pattern ^...) (replace-underscores #'(pattern ^...))))
+         #`(lambda (x)
+             (syntax-case x (k ^...)
+               ((dummy . pattern) #'template)
+               ^...)))))))
+
+(define-syntax case
+  (lambda (stx)
+    (let lp ((stx stx))
+      (syntax-case stx (else)
+        (("case" x)
+         #'(if #f #f))
+        (("case" x ((y ^...) expr ^...) clause ^...)
+         #`(if (memv x '(y ^...))
+               (begin expr ^...)
+               #,(lp #'("case" x clause ^...))))
+        (("case" x (else expr ^...))
+         #'(begin expr ^...))
+        (("case" x clause . ^_)
+         (syntax-violation 'case "bad 'case' clause" #'clause))
+        ((^_ x clause clause* ^...)
+         #`(let ((t x))
+             #,(lp #'("case" t clause clause* ^...))))))))
+
+(define-syntax cond
+  (lambda (stx)
+    (let lp ((stx stx))
+      (syntax-case stx (else =>)
+        (("cond")
+         #'(if #f #f))
+        (("cond" (else expr ^...))
+         #'(begin expr ^...))
+        (("cond" (test => expr) clause ^...)
+         #`(let ((t test))
+             (if t
+                 (expr t)
+                 #,(lp #'("cond" clause ^...)))))
+        (("cond" (test) clause ^...)
+         #`(or test #,(lp #'("cond" clause ^...))))
+        (("cond" (test expr ^...) clause ^...)
+         #`(if test
+               (begin expr ^...)
+               #,(lp #'("cond" clause ^...))))
+        (("cond" clause . ^_)
+         (syntax-violation 'cond "bad 'cond' clause" #'clause))
+        ((^_ clause clause* ^...)
+         (lp #'("cond" clause clause* ^...)))))))
 
 (define (null-environment n)
-  (if (not (= n 5))
+  (unless (eqv? n 5)
-      (scm-error 'misc-error 'null-environment
+    (scm-error 'misc-error 'null-environment
-		 "~A is not a valid version"
+               "~A is not a valid version" (list n) '()))
-		 (list n)
-		 '()))
   ;; Note that we need to create a *fresh* interface
-  (let ((interface (make-module 31)))
+  (let ((interface (make-module)))
     (set-module-kind! interface 'interface)
-    (module-use! interface null-interface)
+    (define bindings
+      '(define quote lambda if set! cond case and or let let* letrec
+	 begin do delay quasiquote unquote
+         define-syntax let-syntax letrec-syntax syntax-rules))
+    (module-use! interface
+                 (resolve-interface '(ice-9 safe-r5rs) #:select bindings))
     interface))

module/ice-9/top-repl.scm

@@ -1,7 +1,6 @@
 ;;; -*- mode: scheme; coding: utf-8; -*-
 
-;;;; Copyright (C) 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
+;;;; Copyright (C) 1995-2011,2013,2019 Free Software Foundation, Inc.
-;;;;   2005, 2006, 2007, 2008, 2009, 2010, 2011, 2013 Free Software Foundation, Inc.
 ;;;;
 ;;;; This library is free software; you can redistribute it and/or
 ;;;; modify it under the terms of the GNU Lesser General Public
@@ -53,8 +52,7 @@
     (set-current-module guile-user-module)
     (process-use-modules 
      (append
-      '(((ice-9 r5rs))
+      '(((ice-9 session)))
-        ((ice-9 session)))
       (if (provided? 'regex)
           '(((ice-9 regex)))
           '())