Treating the values from a list of slots and strings

I want to do a macro in common lisp which is supposed to take in one of its arguments a list made of slots and strings. Here is the prototype :

(defclass time-info ()
  ((name :initarg name)
   (calls :initarg calls)
   (second :initarg second)
   (consing :initarg consing)
   (gc-run-time :initarg gc-run-time)))

(defun print-table (output arg-list time-info-list) ())

The idea is to print a table based on the arg-list which defines its structure. Here is an example of a call to the function开发者_开发知识库:

(print-table *trace-output*
             '("|" name "||" calls "|" second "\")
             my-time-info-list)

This print a table in ascII on the trace output. The problem, is that I don't know how to explicitely get the elements of the list to use them in the different parts of my macro.

I have no idea how to do this yet, but I'm sure it can be done. Maybe you can help me :)

I would base this on format. The idea is to build a format string from your arg-list.

I define a helper function for that:

(defun make-format-string-and-args (arg-list)
  (let ((symbols ()))
    (values (apply #'concatenate 'string
                   (mapcar (lambda (arg)
                             (ctypecase arg
                               (string 
                                (cl-ppcre:regex-replace-all "~" arg "~~"))
                               (symbol
                                (push arg symbols)
                                "~a")))
                           arg-list))
            (nreverse symbols))))

Note that ~ must be doubled in format strings in order to escape them.

The printing macro itself then just produces a mapcar of format:

(defmacro print-table (stream arg-list time-info-list)
  (let ((time-info (gensym)))
    (multiple-value-bind (format-string arguments)
        (make-format-string-and-args arg-list)
      `(mapcar (lambda (,time-info)
                 (format ,stream ,format-string
                         ,@(mapcar (lambda (arg)
                                     (list arg time-info))
                                   arguments)))
               ,time-info-list)))

You can then call it like this:

(print-table *trace-output*
             ("|" name "||" calls "|" second "\\")
             my-time-info-list)

Please note the following errors in your code:

• You need to escape \ in strings.

• Second is already a function name exported from the common-lisp package. You should not clobber that with a generic function.

You need to be more precise with your requirements. Macros and Functions are different things. Arrays and Lists are also different.

We need to iterate over the TIME-INFO-LIST. So that's the first DOLIST.

The table has a description for a line. Each item in the description is either a slot-name or a string. So we iterate over the description. That's the second DOLIST. A string is just printed. A symbol is a slot-name, where we retrieve the slot-value from the current time-info instance.

(defun print-table (stream line-format-description time-info-list)
  (dolist (time-info time-info-list)
    (terpri stream)
    (dolist (slot-or-string line-format-description)
      (princ (etypecase slot-or-string
               (string slot-or-string)
               (symbol (slot-value time-info slot-or-string)))
             stream))))

Test:

> (print-table *standard-output*
               '("|" name "||" calls "|" second "\\")
               (list (make-instance 'time-info
                                    :name "foo"
                                    :calls 100
                                    :second 10)
                     (make-instance 'time-info
                                    :name "bar"
                                    :calls 20
                                    :second 20)))

|foo||100|10\
|bar||20|20\

First, you probably don't want the quote there, if you're using a macro (you do want it there if you're using a function, however). Second, do you want any padding between your separators and your values? Third, you're probably better off with a function, rather than a macro.

You also seem to be using "array" and "list" interchangeably. They're quite different things in Common Lisp. There are operations that work on generic sequences, but typically you would use one way of iterating over a list and another to iterate over an array.