As with special operators, you can define a predicate function to test whether a given form is a macro form.

    You use the previously defined function because you want to allow macros to be used in either of the syntaxes of nonmacro FOO cons forms. However, you need to pass a different predicate function, one that tests whether the form name is a symbol with a non-**NIL** html-macro property. Also, as in the implementation of special operators, you’ll define a macro for defining FOO macros, which is responsible for storing a function in the property list of the macro’s name, under the key html-macro. However, defining a macro is a bit more complicated because FOO supports two flavors of macro. Some macros you’ll define will behave much like normal HTML elements and may want to have easy access to a list of attributes. Other macros will simply want raw access to the elements of their body.

    You can make the distinction between the two flavors of macros implicit: when you define a FOO macro, the parameter list can include an &attributes parameter. If it does, the macro form will be parsed like a regular cons form, and the macro function will be passed two values, a plist of attributes and a list of expressions that make up the body of the form. A macro form without an &attributes parameter won’t be parsed for attributes, and the macro function will be invoked with a single argument, a list containing the body expressions. The former is useful for what are essentially HTML templates. For example:

    1. (define-html-macro :mytag (&attributes attrs &body body)
    2.   `((:div :class "mytag" ,@attrs) ,@body))
    4. HTML> (html (:mytag "Foo"))
    5. <div class='mytag'>Foo</div>
    6. NIL
    7. HTML> (html (:mytag :id "bar" "Foo"))
    8. <div class='mytag' id='bar'>Foo</div>
    9. NIL
    10. HTML> (html ((:mytag :id "bar") "Foo"))
    11. <div class='mytag' id='bar'>Foo</div>
    12. NIL
    1. (define-html-macro :if (test then else)
    2.   `(if ,test (html ,then) (html ,else)))

    This macro allows you to write this:

    instead of this slightly more verbose version:

    1. (:p (if (zerop (random 2)) (html "Heads") (html "Tails")))

    To determine which kind of macro you should generate, you need a function that can parse the parameter list given to define-html-macro. This function returns two values, the name of the &attributes parameter, or **NIL** if there was none, and a list containing all the elements of args after removing the &attributes marker and the subsequent list element.3

    1. (defun parse-html-macro-lambda-list (args)
    3.     (values 
    4.      (cadr attr-cons)
    6. HTML> (parse-html-macro-lambda-list '(a b c))
    7. NIL
    8. (A B C)
    9. HTML> (parse-html-macro-lambda-list '(&attributes attrs a b c))
    10. ATTRS
    11. (A B C)
    12. HTML> (parse-html-macro-lambda-list '(a b c &attributes attrs))
    13. ATTRS
    14. (A B C)

    Now you’re ready to write define-html-macro. Depending on whether there was an &attributes parameter specified, you need to generate one form or the other of HTML macro so the main macro simply determines which kind of HTML macro it’s defining and then calls out to a helper function to generate the right kind of code.

    1. (defmacro define-html-macro (name (&rest args) &body body)
    2.   (multiple-value-bind (attribute-var args)
    3.       (parse-html-macro-lambda-list args)
    4.     (if attribute-var
    5.       (generate-macro-with-attributes name attribute-var args body)
    6.       (generate-macro-no-attributes name args body))))

    The functions that actually generate the expansion look like this:

    1. (defun generate-macro-with-attributes (name attribute-args args body)
    2.   (with-gensyms (attributes form-body)
    3.     (if (symbolp attribute-args) (setf attribute-args `(&rest ,attribute-args)))
    4.        (setf (get ',name 'html-macro-wants-attributes) t)
    6.              (lambda (,attributes ,form-body)
    7.                (destructuring-bind (,@attribute-args) ,attributes
    8.                  (destructuring-bind (,@args) ,form-body
    9.                    ,@body)))))))
    11. (defun generate-macro-no-attributes (name args body)
    12.   (with-gensyms (form-body)
    13.     `(eval-when (:compile-toplevel :load-toplevel :execute)
    14.        (setf (get ',name 'html-macro-wants-attributes) nil)
    15.        (setf (get ',name 'html-macro)
    16.              (lambda (,form-body)
    17.                (destructuring-bind (,@args) ,form-body ,@body)))))

    The macro functions you’ll define accept either one or two arguments and then use **DESTRUCTURING-BIND** to take them apart and bind them to the parameters defined in the call to define-html-macro. In both expansions you need to save the macro function in the name’s property list under html-macro and a boolean indicating whether the macro takes an &attributes parameter under the property html-macro-wants-attributes. You use that property in the following function, expand-macro-form, to determine how the macro function should be invoked:

    1. (defun process (processor form)
    2.   (cond
    3.     ((special-form-p form) (process-special-form processor form))
    4.     ((macro-form-p form)   (process processor (expand-macro-form form)))
    5.     ((sexp-html-p form)    (process-sexp-html processor form))
    6.     (t                     (embed-value processor form))))

    This is the final version of .