anchor.diff:                                :host host)))))))
   
   (defun make-select (name default options)
  -  `((select :name ,name)
  -    ,@(loop for (op text) in options
  -	    if (equal default op)
  -	      collect `((option :value ,op :selected "selected") ,text)
  -	    else
  -	      collect `((option :value ,op) ,text))))
  -
  -(defun make-multi-select (name selected options &key (size (length options)))
  -  `((select :name ,name :multiple "multiple" :size ,size)
  -    ,@(loop for (op text) in options
  -	    if (member op selected :test #'string=)
  -	      collect `((option :value ,op :selected "selected") ,text)
  -	    else
  -	      collect `((option :value ,op) ,text))))
  +  `((select :name ,name :id ,name)
  +    ,@(make-select-options default options)))
  +
  +(defun make-multi-select (name default options &key (size (length options)))
  +  `((select :name ,name :id ,name :multiple "multiple" :size ,size)
  +    ,@(make-select-options default options :multi-select-p t)))
  +
  +(defun make-select-options (default options &key multi-select-p)
  +  (loop for (op text) in options
  +        if (if multi-select-p
  +               (member op default :test #'string-equal)
  +               (string-equal default op))
  +          collect `((option :value ,op :selected "selected") ,text)
  +        else
  +          collect `((option :value ,op) ,text)))
  +
  +(defclass release-handler (handler) ())
  +
  +(defclass implementation-handler (handler) ())
  +
  +(defmethod handle-request-response ((handler release-handler) method request)
  +  (with-db-connection *dbconn*
  +    (param-bind ((host (list "baker") t)
  +                 (implementations nil t)) request
  +      (when (and host implementations)
  +        (mapcar (lambda (elt) (html-stream (request-stream request) elt))
  +                (make-select-options nil
  +                                     (releases-for-implementations host implementations)))))))
  +
  +(defmethod handle-request-response ((handler implementation-handler) method request)
  +  (with-db-connection *dbconn*
  +    (param-bind ((host (list "baker") t)) request
  +      (when host
  +        (mapcar (lambda (elt) (html-stream (request-stream request) elt))
  +                (make-select-options nil
  +                                     (mapcar (lambda (impl) (list impl (pprint-impl-and-mode impl))) (all-implementations-of-host host))))))))
   
   (araneida:attach-hierarchy (http-listener-handler *bench-listener*) *internal-base-url* *base-url*
     ("/" index-handler)
  +  ("/ajax/releases/" release-handler)
  +  ("/ajax/implementations/" implementation-handler)
     ("/atom/"  atom-handler))
   
   
  
positive.code:        ,@body)))
  
  (defun all-implementations-of-host (host &optional preferred-only)
    (iterate (for (impl) in-relation
                  (translate* `(distinct
                                (select ((++ v-name "," result.mode))
                                        (where (join result
                                                     machine-support
                                                     :on (and (= result.m-name machine-support.m-name)
                                                              (= result.v-name machine-support.i-name)
                                                              (= result.mode machine-support.mode)))
                                               (and (in result.m-name ',host)
                                                    ,@(if preferred-only
                                                          '(preferred)
                                                          nil))))))
                  on-connection *dbconn*
                  cursor-name all-host-implementations-cursor)
             (collect impl)))
  
  (defmacro with-db-connection (connection &body body)
    `(let ((,connection (autobench:connect-to-database)))
  
negative.code:           :on (and (= r.v-name v.i-name) (= r.v-version v.version)))
      (and (= r.b-name ,benchmark)
           ,(if only-release
                `(and (>= v.release-date ,earliest)
                      (<= v.release-date ,latest))
                `(or (= v.belongs_to_release v.version)
                     (>= v.release-date ,latest)))
           (in m-name ',host)
           (in b.v-name ',(mapcar #'implementation-spec-impl implementations))
  