macro fu question

[Stefan Israelsson Tampe]

Hi,

I'm working on a small environment to verify macros like the syntax-parse framework.

The idea is to use the tools I've already made for guile/scheme. I will explain this a little
more in detail if anyone is interested. Here I just focus here on a question
about how to use the macro system to solve a design issue.


Here is the idea. Consider to use a pattern system like syntax-case and call it
syntax-parse, the prototype looks familiar as

(syntax-parse stx (literalls ...)  (pat code ....) ...)

The difference is that patterns can have elements like

  (:  p  verifier) added to the standard setup

for this case we will (e.g. for the stx reaching this pattern) will call the verifier (a function) with the stx
to verify it and on success we will continue just as with syntax case else we will log an error
message and continue with the next row and associated pattern and verification. If all patterns 
have been consumed an error message will be deduced and an error message tree can be consulted.

The tool is a function  get-ver :  stx -> (lambda : stx -> boolean)

e.g. get-ver takes an stx representing an extended pattern and constructs a function that takes a
stx representing the incomming code tpo be verified and outputs the verdicet true or false.

and a get-pat that extracts a pattern that can be feeded into syntax-case

I got a PEG tool and a error database system to be able to smootly design verifiers and the get-ver 
system what I find tricky is to design the syntax-parse macro.

I'm working with something like

(define-syntax syntax-parse
  (lambda (x)
    (syntax-case x ()
      ((_ . l)
       (set! *errors* '())
       #'(syntax-parse0 . l)))))

(define-syntax syntax-parse0
  (lambda (x)
    (syntax-case x ()
      ((_ r (p code) . l)               
       (let-syntax ((check-stx (get-ver #'p))
         (with-syntax ((pp (datum->syntax x (get-pat  #'p))))
              #'(lambda (x)              
                  (define-syntax rest 
                    (lambda (x)
                      (syntax-case x r
                        (pp code)
                        (_  (print-error)
                            #'(error "MACRO-SYNTAX-ERROR")))))
                  (syntax-case x ()
                    ((x . l)
                     #'(if (check-stx . l)
                           (rest . l)
                           (syntax-parse0 r . l)))))))



/stefan

by the way, One shouled be able to mod the PEG parser going into guile to do all the main job here at
constructing verifiers, also to ote is that I mod car cdr pair? etc to be able to handle syntax objkect
and transfered syntax-object? syntax-object-_expression_ into guile namespace to be able to keep source and syntactic information consistent.