Macros calling macros

Similar Threads:

1.Macrology: Macro for calling macro defcallback (OpenMCL)

Hi all:

I want to define a macro to call the defcallback macro in OpenMCL. 
I assume it's my basic knowledge of macrology and not a problem of
a specific implementation.

So, any hints on the following non-working source code is 
appreciated!

#1: Definition of the DEFCALLBACK macro in OpenMCL:

Macro  DEFCALLBACK 

Syntax:  defcallback name ({arg-type-specifier var}*   
                          &optional result-type-specifier)   
                          &body   body 

#2: Working example from OpenMCL's example source code

(ccl::defcallback reshape-cb (:int w :int h)
    (format t "reshape-cb: w=~D h=~D~%" w h))


#3: My macro:

(defmacro ff-defun-callable (call-convention result-type name args &body body)
  (declare (ignorable result-type))
  (declare (ignorable call-convention))
  `(ccl:defcallback ,name
	            ,(list args)
                    ,@body))

Problem/error I get is:

Unknown foreign type: (:VOID)
   [Condition of type SIMPLE-ERROR]

Backtrace:
  0: (CCL::%PARSE-FOREIGN-TYPE '((:VOID)))
  1: (CCL::PARSE-FOREIGN-TYPE '(:VOID))
  2: (CCL::FOREIGN-TYPE-TO-REPRESENTATION-TYPE '((:VOID)))
  3: (DEFINE-CALLBACK 'CL-OPENGL::MGWCLOSE '((:VOID)) '((PRINT "closing callback entered")) #<CCL::LEXICAL-ENVIRONMENT #x69C5BE6>)
      Locals:
        CCL::NAME = CL-OPENGL::MGWCLOSE
        CCL::ARGS = ((:VOID))
        CCL::BODY = ((PRINT "closing callback entered"))
        CCL::ENV = #<CCL::LEXICAL-ENVIRONMENT #x69C5BE6>
        CCL::STACK-WORD = #:G24663
        CCL::STACK-PTR = #:G24664
        CCL::RETURN-TYPE = #<VALUE-CELL (:VOID) #x69D259E>
        CCL::WOI = #<VALUE-CELL NIL #x69D2596>
        CCL::MONITOR = #<VALUE-CELL NIL #x69D258E>
        CCL::DYNAMIC-EXTENT-NAMES = #<VALUE-CELL NIL #x69D2586>
        CCL::ERROR-RETURN = #<VALUE-CELL NIL #x69D257E>
      [No catch-tags]

So, I know I have to get rid of the args being passed as a list - 
or that's what I assume, anyway. Is that true?

When passing ,args without being a list I get another error indicating that passing the args and the name of the callback got mixed up. So...?????

Thx for any help here! If I should provide more info pls tell me!

Frank

2.Macro-writing macro - interpreting dynamic keyword arguments for use in 2nd-level macro

Hi,

I'm working on a macro that does substantial lifting. I've hit a snag,
however, and even though I can see where the issue is I know that I
don't fully understand the computational reason for the failure, or
else I would know either (a) I'm trying the impossible, or (b) how to
overcome the problem.

Anyway, introduction aside, here's the issue.

I have a macro (MKINSTANCER) that can inspect a lists (one might be
called OB1) expressed in my own grammar, and based on it will
construct another macro (e.g. OB1-INSTANCER) with keyword arguments
based on the slots defined by OB1 (basically constructing an object
and setting slot values according to the keyword arguments passed to
OB1-INSTANCER).
To enhance MACX, I want it to insert logic into resulting macros that
it writes, to only process keyword arguments if the user supplied
values.

The problem is that the expressions I've written don't evaluate to the
values supplied as keyword values, but instead try to evaluate unbound
variables with the same names (symbols?) you would usually use to pick
up the values of the keyword arguments.

Here is a version of MKINSTANCER that highlights the problem:

(defmacro mkinstancer (instancer-name)
	  (let* ((keyw-args `((HEIGHT NIL HEIGHT-SUPPLIED-P) (WIDTH NIL WIDTH-
SUPPLIED-P)))
		 (keyw-args-q (mapcar #'(lambda (x) (list 'quote x)) keyw-args)))
	    `(defmacro ,instancer-name (&key ,@keyw-args)
	       `(progn
		  ,@(mapcar #'(lambda (val)
				`(princ ,(first (second val))))
		  (quote ,keyw-args-q))))))
..............................................................................

What this would generate when called is shown by the following
macroexpansion:

(macroexpand-1 `(mkinstancer instancer1))
(DEFMACRO INSTANCER1
          (&KEY (HEIGHT () HEIGHT-SUPPLIED-P) (WIDTH () WIDTH-SUPPLIED-
P))
  `(PROGN
    ,@(MAPCAR #'(LAMBDA (VAL) `(PRINC ,(FIRST (SECOND VAL))))
              '('(HEIGHT NIL HEIGHT-SUPPLIED-P)
                '(WIDTH NIL WIDTH-SUPPLIED-P)))))

..............................................................................

I then create my "2nd-level" macro like so:

    (mkinstancer instancer1)

And this has the following sample macroexpansion:
     (macroexpand-1 `(instancer1 :height 45 :width 90))
     (PROGN (PRINC HEIGHT) (PRINC WIDTH))

..............................................................................

I am trying to get this to be instead: "(PROGN (PRINC 45) (PRINC
90))".

Why I actually call the macro "instancer1", I get the following
backtrace (showing I'm referencing unbound variable HEIGHT):

The variable HEIGHT is unbound.
   [Condition of type UNBOUND-VARIABLE]

Restarts:
 0: [ABORT] Return to SLIME's top level.
 1: [TERMINATE-THREAD] Terminate this thread (#<THREAD "repl-
thread" {AF8C939}>)

Backtrace:
  0: (SB-INT:SIMPLE-EVAL-IN-LEXENV HEIGHT #<NULL-LEXENV>)
  1: (SB-INT:SIMPLE-EVAL-IN-LEXENV (PRINC HEIGHT) #<NULL-LEXENV>)
  2: (SB-IMPL::SIMPLE-EVAL-PROGN-BODY
      ((PRINC HEIGHT) (PRINC WIDTH))
      #<NULL-LEXENV>)
  3: (SB-INT:SIMPLE-EVAL-IN-LEXENV
      (INSTANCER1 :HEIGHT 45 :WIDTH 90)
      #<NULL-LEXENV>)
 --more--

========================

I know this has been a long post but I hope I've expressed the
situation clearly enough for someone to suggest a path to
illumination.

I'm using SBCL 1.0.7 on Linux (Ubuntu Gutsy Gibbon).

Joubert

PS: In my wanderings I've experimented with different combinations of
symbol-value, find-symbol, etc. in the (mapcar) expression because I
thought the problem is a symbol lookup mismatch.

3.Macro question (Guile define-macro)

4.macros within macros

L.S.,

Suppose I have a macro M1 that defines a macro. Lets define
a new macro using this macro:

(M1 new+ (number? number?) +)

Now, suppose I'd like to redefine the new+ macro, using the
previous definition of of itself:

(M1 new+ (string? number?) 
   (lamda (a b) (string-append a (number->string b))))

At this point, I'd like to see:

(new+ 2 3) -> 5
(new+ "a" 2) -> "a2"

I have an implementation, which is about:

(M1 new+ (number? number?) +)
(M1 newnew+ new+ (string? number?) 
   (lamda (a b) (string-append a (number->string b))))

But this is not what I'm trying to do. 

Can this be done using R5RS macro definitions?

Best regards,

Hans

5.expanding macros and passing the results to other macros

Hi,

I'm messing about with the PLT Scheme parser tools (just the lexer at 
the moment). My problem isn't specific to that though, it's getting my 
head around all the macro expansion that's going on. I don't think I'm 
using the quasiquote properly (too many commas).

For anyone that hasn't used the lexer, it looks a little like this:

  (lexer
    ("a"   <a-rule>)
    ("b"   <b-rule>))

and it's a complex macro (so a noob like me has no chance of tracing 
through it).

I want to lex a collection of keywords, and have a separate symbol token 
for each one. This is going to give code like:

  (lexer
    ("keyword1"   'token-keyword1)
    ("keyword2"   'token-keyword2)
    ("keyword3"   'token-keyword3)
    ("keyword4"   'token-keyword4)
    ...
    ; some non-keyword rules
    )

You can probably see where I'm going with this already, but I'd like to 
replace the long list with something more like:


  (lexer
    (map make-keyword-rule keywords)
    ...
    ; some non-keyword rules
    )

Using:

(define (string->keyword-token keyword-string)
   (string->symbol (string-append "token-" keyword-string)))

(define (make-keyword-rule keyword-string)
   `(,keyword-string (',(string->keyword-token keyword-string))))


But I just can't figure it. All I'm doing is expanding to one form that 
needs splicing into another before being transformed again by the lexer 
macro. OK, that doesn't sound so simple now I've typed it out loud.

So, is it possible? Is it just a case of getting me quotes in a tangle?

Thanks in advance,
pt.

6. SRFI-46: Ellipsis in Macro-Generating SYNTAX-RULES Macros

7. Macros in Macros in Gambit

8. Macro language design. Was: The Advantage of Macros