bootstrap: Add bootstrap build scripts.
[mes.git] / tests / psyntax.test
1 #! /bin/sh
2 # -*-scheme-*-
3 MES=${MES-$(dirname $0)/../scripts/mes}
4 echo ' ()' | cat $(dirname $0)/../module/mes/base-0.mes $0 /dev/stdin | $MES $MES_FLAGS "$@"
5 #paredit:||
6 exit $?
7 !#
8
9 ;;; -*-scheme-*-
10
11 ;;; Mes --- Maxwell Equations of Software
12 ;;; Copyright © 2016 Jan 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 (when (not guile?)
50  (pass-if "andmap"
51    (seq? (andmap (lambda (x) (> x 0)) '(3 2 1)) #t))
52
53  (pass-if "andmap 2"
54    (seq? (andmap (lambda (x) (> x 0)) '(3 2 1 0)) #f))
55
56  (pass-if "putprop" (putprop 'foo '*sc-expander 'bar))
57
58  (pass-if "getprop"
59    (seq? (getprop 'foo '*sc-expander) 'bar))
60  )
61
62 (pass-if "syntax-case"
63   (sequal? (let* ((sexp '(syntax-case '((1 2) (3 4)) ()
64                            (((x ...) ...) (syntax (x ... ...)))))
65                   (expanded (sc-expand sexp)))
66              (primitive-eval expanded))
67            '(1 2 3 4)))
68
69 (pass-if "sc-expand"
70   (sequal? (let ()
71              (syntax-case '((1 2) (3 4)) ()
72                (((x ...) ...) (syntax (x ... ...)))))
73            '(1 2 3 4)))
74
75 (pass-if "syntax-object->datum"
76   (sequal? (syntax-object->datum (syntax (set! a b)))
77            '(set! a b)))
78
79 (pass-if "syntax-case swap!"
80   (sequal? (syntax-object->datum
81             (let ((exp '(set! a b)))
82               (syntax-case exp ()
83                 ((swap! a b)
84                  (syntax
85                   (let ((temp a))
86                     (set! a b)
87                     (set! b temp)))))))
88            '(let ((temp a)) (set! a b) (set! b temp))))
89
90 (when (not guile?)
91   (pass-if "syntax-case manual swap!"
92     (sequal?
93      (let* ((sc (sc-expand '(syntax-case exp () ((swap! a b) (syntax (let ((temp a)) (set! a b) (set! b temp)))))))
94             (exp '(swap foo bar))
95             (foo "foo")
96             (bar "bar")
97             (s (eval sc (current-module)))
98             (d (syntax-object->datum s)))
99        (eval d (current-module))
100        (list foo bar))
101      '("bar" "foo"))))
102
103 (pass-if "define-syntax swap! [syntax-case]"
104   (sequal?
105    (let ()
106      (define-syntax swap!
107        (lambda (exp)
108          (syntax-case exp ()
109            ((swap! a b)
110             (syntax
111              ((lambda (temp)
112                 (set! a b)
113                 (set! b temp)) a))))))
114      (let ((foo "foo")
115            (bar "bar"))
116        (swap! foo bar)
117        (list foo bar)))
118    (list "bar" "foo")))
119
120 (pass-if "define-syntax swap! [syntax-case+let]"
121   (sequal?
122    (let ()
123      (define-syntax swap!
124        (lambda (exp)
125          (syntax-case exp ()
126            ((swap! a b)
127             (syntax
128              (let ((temp a))
129                (set! a b)
130                (set! b temp)))))))
131      (let ((foo "foo")
132            (bar "bar"))
133        (swap! foo bar)
134        (list foo bar)))
135    (list "bar" "foo")))
136
137 (pass-if "define-syntax sr:when [syntax-rules]"
138   (sequal?
139    (let ()
140      (define-syntax sr:when
141        (syntax-rules ()
142          ((sc:when condition exp ...)
143           (if condition
144               (begin exp ...)))))
145      (let ()
146        (sr:when #t "if not now, then?")))
147    "if not now, then?"))
148
149 (pass-if "define-syntax-rule"
150   (sequal?
151    (let ()
152      (define-syntax-rule (sre:when c e ...)
153        (if c (begin e ...)))
154      (let ()
155        (sre:when #t "if not now, then?")))
156    "if not now, then?"))
157
158 (pass-if-equal "syntax-rules plus"
159     (+ 1 2 3)
160   (let ()
161     (define-syntax plus
162       (syntax-rules ()
163         ((plus x ...) (+ x ...))))
164     (plus 1 2 3)))
165
166 (when guile?
167   (pass-if-equal "macro with quasisyntax"
168       '("foo" "foo")
169     (let ()
170       (define-syntax string-let
171         (lambda (stx)
172           (syntax-case stx ()
173             ((_ id body ...)
174              #`(let ((id #,(symbol->string (syntax->datum #'id))))
175                  body ...)))))
176       (string-let foo (list foo foo)))))
177
178   ;; (pass-if-equal "custom ellipsis within normal ellipsis"
179   ;;     '((((a x) (a y) (a …))
180   ;;        ((b x) (b y) (b …))
181   ;;        ((c x) (c y) (c …)))
182   ;;       (((a x) (b x) (c x))
183   ;;        ((a y) (b y) (c y))
184   ;;        ((a …) (b …) (c …))))
185   ;;   (let ()
186   ;;     (define-syntax foo
187   ;;       (syntax-rules ()
188   ;;         ((_ y ...)
189   ;;          (syntax-rules … ()
190   ;;            ((_ x …)
191   ;;             '((((x y) ...) …)
192   ;;               (((x y) …) ...)))))))
193   ;;     (define-syntax bar (foo x y …))
194   ;;     (bar a b c)))
195
196 (let ()
197  (define-syntax define-quotation-macros
198    (lambda (x)
199      (syntax-case x ()
200        ((_ (macro-name head-symbol) ...)
201         #'(begin (define-syntax macro-name
202                    (lambda (x)
203                      (with-ellipsis :::
204                                     (syntax-case x ()
205                                       ((_ x :::)
206                                        #'(quote (head-symbol x :::)))))))
207                  ...)))))
208  (define-quotation-macros (quote-a a) (quote-b b) (quote-c c))
209
210  (pass-if-equal "with-ellipsis"
211      '(a 1 2 3)
212      (quote-a 1 2 3)))
213
214 (result 'report (if (and guile?
215                          (equal? (effective-version) "2.0")) 1
216                          0))