Making the Dream a Reality

Okay, enough fantasizing about good-looking code; now you need to get to work writing define-binary-class--writing the code that will turn that concise expression of what an ID3 tag looks like into code that can represent one in memory, read one off disk, and write it back out.

To start with, you should define a package for this library. Here’s the package file that comes with the version you can download from the book’s Web site:

  1. (in-package :cl-user)
  3. (defpackage :com.gigamonkeys.binary-data
  4.   (:use :common-lisp :com.gigamonkeys.macro-utilities)
  5.   (:export :define-binary-class
  6.            :define-tagged-binary-class
  7.            :define-binary-type
  8.            :read-value
  9.            :write-value
  10.            :*in-progress-objects*
  11.            :parent-of-type
  12.            :current-binary-object
  13.            :+null+))

The COM.GIGAMONKEYS.MACRO-UTILITIES package contains the with-gensyms and once-only macros from Chapter 8.

Since you already have a handwritten version of the code you want to generate, it shouldn’t be too hard to write such a macro. Just take it in small pieces, starting with a version of define-binary-class that generates just the **DEFCLASS** form.

If you look back at the define-binary-class form, you’ll see that it takes two arguments, the name id3-tag and a list of slot specifiers, each of which is itself a two-item list. From those pieces you need to build the appropriate **DEFCLASS** form. Clearly, the biggest difference between the define-binary-class form and a proper **DEFCLASS** form is in the slot specifiers. A single slot specifier from define-binary-class looks something like this:

  1. (major-version u1)

But that’s not a legal slot specifier for a **DEFCLASS**. Instead, you need something like this:

  1. (major-version :initarg :major-version :accessor major-version)

Easy enough. First define a simple function to translate a symbol to the corresponding keyword symbol.

  1. (defun as-keyword (sym) (intern (string sym) :keyword))

Now define a function that takes a define-binary-class slot specifier and returns a **DEFCLASS** slot specifier.

  1. (defun slot->defclass-slot (spec)
  2.   (let ((name (first spec)))
  3.     `(,name :initarg ,(as-keyword name) :accessor ,name)))

You can test this function at the REPL after switching to your new package with a call to **IN-PACKAGE**.

  1. BINARY-DATA> (slot->defclass-slot '(major-version u1))
  2. (MAJOR-VERSION :INITARG :MAJOR-VERSION :ACCESSOR MAJOR-VERSION)

Looks good. Now the first version of define-binary-class is trivial.

  1. (defmacro define-binary-class (name slots)
  2.   `(defclass ,name ()
  3.      ,(mapcar #'slot->defclass-slot slots)))

This is simple template-style macro—define-binary-class generates a **DEFCLASS** form by interpolating the name of the class and a list of slot specifiers constructed by applying slot->defclass-slot to each element of the list of slots specifiers from the define-binary-class form.

To see exactly what code this macro generates, you can evaluate this expression at the REPL.

  1. (macroexpand-1 '(define-binary-class id3-tag
  2.   ((identifier      (iso-8859-1-string :length 3))
  3.    (major-version   u1)
  4.    (revision        u1)
  5.    (flags           u1)
  6.    (size            id3-tag-size)
  7.    (frames          (id3-frames :tag-size size)))))

The result, slightly reformatted here for better readability, should look familiar since it’s exactly the class definition you wrote by hand earlier:

  1. (defclass id3-tag ()
  2.   ((identifier      :initarg :identifier    :accessor identifier)
  3.    (major-version   :initarg :major-version :accessor major-version)
  4.    (revision        :initarg :revision      :accessor revision)
  5.    (flags           :initarg :flags         :accessor flags)
  6.    (size            :initarg :size          :accessor size)
  7.    (frames          :initarg :frames        :accessor frames)))