441e782d083c2142e1b9d016297562e5af466f17
[mes.git] / tests / psyntax.test
1 #! /bin/sh
2 # -*-scheme-*-
3 MES=${MES-$(dirname $0)/../src/mes}
4 #export MES_ARENA=${MES_ARENA-200000}
5 $MES $MES_FLAGS "$@" < $0
6 exit $?
7 !#
8
9 ;;; -*-scheme-*-
10
11 ;;; Mes --- Maxwell Equations of Software
12 ;;; Copyright © 2016,2018 Jan (janneke) Nieuwenhuizen <janneke@gnu.org>
13 ;;;
14 ;;; This file is part of Mes.
15 ;;;
16 ;;; Mes is free software; you can redistribute it and/or modify it
17 ;;; under the terms of the GNU General Public License as published by
18 ;;; the Free Software Foundation; either version 3 of the License, or (at
19 ;;; your option) any later version.
20 ;;;
21 ;;; Mes is distributed in the hope that it will be useful, but
22 ;;; WITHOUT ANY WARRANTY; without even the implied warranty of
23 ;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
24 ;;; GNU General Public License for more details.
25 ;;;
26 ;;; You should have received a copy of the GNU General Public License
27 ;;; along with Mes.  If not, see <http://www.gnu.org/licenses/>.
28
29 (cond-expand
30  (guile-2.2
31   (define sc-expand identity)
32   (define syntax-object->datum syntax->datum)
33   (define datum->syntax-object datum->syntax))
34  (guile-2
35   (define sc-expand identity)
36   (define syntax-object->datum syntax->datum)
37   (define datum->syntax-object datum->syntax)
38   (define-macro (with-ellipsis . stuff) #t))
39  (guile
40   (use-modules (ice-9 syncase))
41   (define sc-expand identity))
42  (mes
43   (mes-use-module (mes psyntax))
44   (mes-use-module (mes test))))
45
46 (pass-if "first dummy" #t)
47 (pass-if-not "second dummy" #f)
48
49 (cond-expand
50  (guile)
51  (mes
52   (pass-if "andmap"
53     (seq? (andmap (lambda (x) (> x 0)) '(3 2 1)) #t))
54
55   (pass-if "andmap 2"
56     (seq? (andmap (lambda (x) (> x 0)) '(3 2 1 0)) #f))
57
58   (pass-if "putprop" (putprop 'foo '*sc-expander 'bar))
59
60   (pass-if "getprop"
61     (seq? (getprop 'foo '*sc-expander) 'bar)))
62  )
63
64 (pass-if "syntax-case"
65   (sequal? (let* ((sexp '(syntax-case '((1 2) (3 4)) ()
66                            (((x ...) ...) (syntax (x ... ...)))))
67                   (expanded (sc-expand sexp)))
68              (primitive-eval expanded))
69            '(1 2 3 4)))
70
71 (pass-if "sc-expand"
72   (sequal? (let ()
73              (syntax-case '((1 2) (3 4)) ()
74                (((x ...) ...) (syntax (x ... ...)))))
75            '(1 2 3 4)))
76
77 (pass-if "syntax-object->datum"
78   (sequal? (syntax-object->datum (syntax (set! a b)))
79            '(set! a b)))
80
81 (pass-if-equal "syntax-case swap!"
82     '((lambda (temp)
83         (set! a b)
84         (set! b temp))
85       a)
86   (syntax-object->datum
87    (let ((exp '(set! a b)))
88      (syntax-case exp ()
89        ((swap! a b)
90         (syntax
91          ((lambda (temp)
92             (set! a b)
93             (set! b temp))
94           a)))))))
95
96 (pass-if-equal "syntax-case swap! let"
97     '(let ((temp a)) (set! a b) (set! b temp))
98   (syntax-object->datum
99    (let ((exp '(set! a b)))
100      (syntax-case exp ()
101        ((swap! a b)
102         (syntax
103          (let ((temp a))
104            (set! a b)
105            (set! b temp))))))))
106
107 (cond-expand
108  (guile)
109  (mes
110   (pass-if-equal "syntax-case manual swap!"
111       '("bar" "foo")
112     (let* ((sc (sc-expand '(syntax-case exp () ((swap! a b) (syntax (let ((temp a)) (set! a b) (set! b temp)))))))
113            (exp '(swap foo bar))
114            (foo "foo")
115            (bar "bar")
116            (s (eval sc (current-module)))
117            (d (syntax-object->datum s))
118            (e (core:macro-expand d)))
119       (eval e (current-module))
120       (list foo bar)))))
121
122 (pass-if-equal "define-syntax swap! [syntax-case]"
123     (list "bar" "foo")
124   (let ()
125     (define-syntax swap!
126       (lambda (exp)
127         (syntax-case exp ()
128           ((swap! a b)
129            (syntax
130             ((lambda (temp)
131                (set! a b)
132                (set! b temp)) a))))))
133     (let ((foo "foo")
134           (bar "bar"))
135       (swap! foo bar)
136       (list foo bar))))
137
138 (pass-if-equal "define-syntax swap! [syntax-case+let]"
139   (list "bar" "foo")
140   (let ()
141     (define-syntax swap!
142       (lambda (exp)
143         (syntax-case exp ()
144           ((swap! a b)
145            (syntax
146             (let ((temp a))
147               (set! a b)
148               (set! b temp)))))))
149     (let ((foo "foo")
150           (bar "bar"))
151       (swap! foo bar)
152       (list foo bar))))
153
154 (pass-if-equal "define-syntax sr:when [syntax-rules]"
155     "if not now, then?"
156   (let ()
157     (define-syntax sr:when
158       (syntax-rules ()
159         ((sc:when condition exp ...)
160          (if condition
161              (begin exp ...)))))
162     (let ()
163       (sr:when #t "if not now, then?"))))
164
165 (pass-if-equal "define-syntax-rule"
166     "if not now, then?"
167   (let ()
168     (define-syntax-rule (sre:when c e ...)
169       (if c (begin e ...)))
170     (let ()
171       (sre:when #t "if not now, then?"))))
172
173 (pass-if-equal "syntax-rules plus"
174     (+ 1 2 3)
175   (let ()
176     (define-syntax plus
177       (syntax-rules ()
178         ((plus x ...) (+ x ...))))
179     (plus 1 2 3)))
180
181 (cond-expand
182  (guile
183   (pass-if-equal "macro with quasisyntax"
184       '("foo" "foo")
185     (let ()
186       (define-syntax string-let
187         (lambda (stx)
188           (syntax-case stx ()
189             ((_ id body ...)
190              #`(let ((id #,(symbol->string (syntax->datum #'id))))
191                  body ...)))))
192       (string-let foo (list foo foo)))))
193  (mes))
194
195   ;; (pass-if-equal "custom ellipsis within normal ellipsis"
196   ;;     '((((a x) (a y) (a …))
197   ;;        ((b x) (b y) (b …))
198   ;;        ((c x) (c y) (c …)))
199   ;;       (((a x) (b x) (c x))
200   ;;        ((a y) (b y) (c y))
201   ;;        ((a …) (b …) (c …))))
202   ;;   (let ()
203   ;;     (define-syntax foo
204   ;;       (syntax-rules ()
205   ;;         ((_ y ...)
206   ;;          (syntax-rules … ()
207   ;;            ((_ x …)
208   ;;             '((((x y) ...) …)
209   ;;               (((x y) …) ...)))))))
210   ;;     (define-syntax bar (foo x y …))
211   ;;     (bar a b c)))
212
213 (let ()
214  (define-syntax define-quotation-macros
215    (lambda (x)
216      (syntax-case x ()
217        ((_ (macro-name head-symbol) ...)
218         #'(begin (define-syntax macro-name
219                    (lambda (x)
220                      (with-ellipsis :::
221                                     (syntax-case x ()
222                                       ((_ x :::)
223                                        #'(quote (head-symbol x :::)))))))
224                  ...)))))
225  (define-quotation-macros (quote-a a) (quote-b b) (quote-c c))
226
227  (pass-if-equal "with-ellipsis"
228      '(a 1 2 3)
229      (quote-a 1 2 3)))
230
231 (result 'report (if (and guile?
232                          (equal? (effective-version) "2.0")) 1
233                          0))