src/: Abolish the distinction between different kinds of initializers.

[sod] / src / module-parse.lisp

diff --git a/src/module-parse.lisp b/src/module-parse.lisp
index a45892216da5c362beb0b2493576078e30f7ac16..2866c08aa4288359619820380394ef723e2a9b93 100644 (file)
--- a/src/module-parse.lisp
+++ b/src/module-parse.lisp
@@ -253,50 +253,12 @@ (defun parse-class-body (scanner pset name supers)
                                           body sub-pset scanner))))
 
               (parse-initializer ()
-                ;; initializer ::= `=' c-fragment | `=' `{' c-fragment `}'
+                ;; initializer ::= `=' c-fragment
                 ;;
-                ;; Return (VALUE-KIND . VALUE-FORM), ready for passing to a
-                ;; `sod-initializer' constructor.
-
-                ;; This is kind of tricky because we have to juggle both
-                ;; layers of the parsing machinery.  The character scanner
-                ;; will already have consumed the lookahead token (which, if
-                ;; we're going to do anything, is `=').
-                (let ((char-scanner (token-scanner-char-scanner scanner)))
-
-                  ;; First, skip the character-scanner past any whitespace.
-                  ;; We don't record this consumption, which is a bit
-                  ;; naughty, but nobody will actually mind.
-                  (loop
-                    (when (or (scanner-at-eof-p char-scanner)
-                              (not (whitespace-char-p
-                                    (scanner-current-char char-scanner))))
-                      (return))
-                    (scanner-step char-scanner))
-
-                  ;; Now maybe read an initializer.
-                  (cond ((not (eql (token-type scanner) #\=))
-                         ;; It's not an `=' after all.  There's no
-                         ;; initializer.
-                         (values '(#\=) nil nil))
-
-                        ((and (not (scanner-at-eof-p char-scanner))
-                              (char= (scanner-current-char char-scanner)
-                                     #\{))
-                         ;; There's a brace after the `=', so we should
-                         ;; consume the `=' here, and read a compound
-                         ;; initializer enclosed in braces.
-                         (parse (seq (#\= (frag (parse-delimited-fragment
-                                                 scanner #\{ #\})))
-                                  (cons :compound frag))))
-
-                        (t
-                         ;; No brace, so read from the `=' up to, but not
-                         ;; including, the trailing `,' or `;' delimiter.
-                         (parse (seq ((frag (parse-delimited-fragment
-                                             scanner #\= '(#\; #\,)
-                                             :keep-end t)))
-                                  (cons :simple frag)))))))
+                ;; Return a VALUE, ready for passing to a `sod-initializer'
+                ;; constructor.
+                (parse-delimited-fragment scanner #\= (list #\, #\;)
+                                          :keep-end t))
 
               (parse-slot-item (sub-pset base-type type name)
                 ;; slot-item ::=
@@ -310,8 +272,7 @@ (defun parse-class-body (scanner pset name supers)
                                              sub-pset scanner)
                               (when init
                                 (make-sod-instance-initializer
-                                 class nick name (car init) (cdr init)
-                                 sub-pset scanner)))
+                                 class nick name init sub-pset scanner)))
                             (skip-many ()
                               (seq (#\,
                                     (ds (parse-declarator scanner
@@ -321,8 +282,7 @@ (defun parse-class-body (scanner pset name supers)
                                                sub-pset scanner)
                                 (when init
                                   (make-sod-instance-initializer
-                                   class nick (cdr ds)
-                                   (car init) (cdr init)
+                                   class nick (cdr ds) init
                                    sub-pset scanner))))
                             #\;)))
 
@@ -335,8 +295,7 @@ (defun parse-class-body (scanner pset name supers)
                               (seq ((name-a :id) #\. (name-b :id)
                                     (init (parse-initializer)))
                                 (funcall constructor class
-                                         name-a name-b
-                                         (car init) (cdr init)
+                                         name-a name-b init
                                          sub-pset scanner))
                               #\,)
                             #\;)))