fix splitter

quad/quad/split.rkt

@@ -3,7 +3,7 @@
 
 ;; push together multiple attr sources into one list of pairs.
 ;; mostly a helper function for the two attr functions below.
-(define (join-attrs quads-or-attrs-or-lists)
+#;(define (join-attrs quads-or-attrs-or-lists)
     (append-map hash->list (filter-not false? (map (λ(x)
                                                      (cond
                                                        [(quad? x) (quad-attrs x)]
@@ -14,7 +14,7 @@
 
 ;; flatten merges attributes, but applies special logic suitable to flattening
 ;; for instance, resolving x and y coordinates.
-(define (flatten-attrs . quads-or-attrs-or-falses)
+#;(define (flatten-attrs . quads-or-attrs-or-falses)
     (define all-attrs (join-attrs quads-or-attrs-or-falses))
     (define-values (x-attrs y-attrs other-attrs-reversed)
       (for/fold ([xas null][yas null][oas null])([attr (in-list all-attrs)])
@@ -28,7 +28,7 @@
 
 ;; pushes attributes down from parent quads to children, 
 ;; resulting in a flat list of quads.
-(define (flatten-quad q)
+#;(define (flatten-quad q)
     (flatten
      (let loop ([x q][parent #f])
        (cond       
@@ -47,7 +47,7 @@
 ;; flatten quad as above, 
 ;; then dissolve it into individual character quads while copying attributes
 
-(define (split-quad q)
+#;(define (split-quad q)
     (letrec ([do-explode (λ(x [parent #f])
                            (cond
                              [(quad? x)
@@ -59,12 +59,17 @@
       (flatten (map do-explode (flatten-quad q)))))
 
 (require (for-syntax syntax/strip-context sugar/debug))
+(define-for-syntax ctx #'here)
 (define-syntax (stx-quad stx)
   (syntax-case stx ()
-    [(_ ((ATTR-NAME ATTR-VAL) ...) XS)
-     (with-syntax ([(NEW-ATTR-NAME ...) (map (λ(an) (replace-context #'here an)) (syntax->list #'(ATTR-NAME ...)))])
+    [(_ QUAD-NAME ((ATTR-NAME ATTR-VAL) ...) XS)
+     (with-syntax ([(NEW-ATTR-NAME ...) (map (λ(an) (datum->syntax stx (syntax->datum an))) (syntax->list #'(ATTR-NAME ...)))]
+                   [(ALL-ATTR-NAME ...) (map (λ(n) (datum->syntax stx n)) '(size font))])
        #'(let ([NEW-ATTR-NAME ATTR-VAL] ...)
-           (for-each (λ(x) (println (list size x))) XS)))]))
+           (append-map (λ(x) (if (string? x)
+                                 (for/list ([c (in-string x)])
+                                           (vector ALL-ATTR-NAME ... c))
+                                 x)) XS)))]))
 
 
 (require racket/generator)
@@ -75,5 +80,7 @@
 (split-quad x)
 |#
 
-(define x2 (stx-quad ((size 10)) (list "bar" (stx-quad ((size 8)) '("zam")) "qux")))
-x2
+;(define x2 (stx-quad ((size 10)(font "Eq")) (list "bar" (stx-quad ((size 8)) '("zam")) "qux")))
+;x2
+
+(stx-quad 'foo ((size 10)(font "Eq")) (list "bar" (stx-quad 'foo ((size 8)) '("zam")) "qux"))