anchor.diff:       :features ("native threads"
                   "embeddable"
                   "compact code"
  -                "small C++ kernel for bootstrapping")
  +                "small C++ kernel for bootstrapping"
  +                "experimental"
  +                "slow startup"
  +                "minimalist")
        :mostly-written-in ("C++"))
  -
  +    ;; xcl is experimental. Lacking a lot of features. Rather slow, at least at startup.
       
       (:name "WCL"
        :license "Proprietary"
  
positive.code:    (function string<)))
  
  
  (defun process-answer-line (line)
    (let ((line (substitute-if #\space (lambda (ch) (find ch "	,.;()[]!:")) line)))
      (when (every (lambda (ch) (or (char= #\space ch) (digit-char-p ch))) line)
        (let ((answer (with-input-from-string (inp line)
                         (loop
                           :for index = (read inp nil nil)
                           :while index :collect index))))
          (if (= 1 (length answer))
              (first answer)
              answer)))))
  
  
  (defun select (field &optional (implementations *implementations*))
  
negative.code:   #+ecl                  (ext:quit status)
    #+sbcl                 (sb-ext:quit status)
    #-(or ccl clisp cmu ecl sbcl) (throw 'quit))
  
  
  (defun getenv (var)
    #+ccl           (ccl::getenv var)
    #+clisp         (ext:getenv var)
    #+CMU           (cdr (assoc var ext:*environment-list* :test #'string=))
    #+ecl           (ext:getenv var)
    #+SBCL          (sb-ext:posix-getenv var)
    #+Allegro       (sys:getenv var)
    #+Lispworks     (lispworks:environment-variable var)
    #-(or ccl
          clisp
          cmu
          ecl
          sbcl
          allegro
          lispworks) (iolib.syscalls:getenv var))
  
  
  (defun prefixp (prefix string &key (start 0) (end nil) (test (function char=)))
    "
  PREFIX:  A sequence.
  STRING:  A sequence.
  START:   The start of the substring of STRING to consider. Default: 0.
  END:     The end   of the substring of STRING to consider. Default: NIL.
  TEST:    A function to compare the elements of the strings.
  RETURN:  Whether PREFIX is a prefix of the (substring STRING START END).
  "
    (let ((mis (mismatch prefix string :start2 start :end2 end :test test)))
      (or (null mis) (<= (length prefix) mis))))
  
  
  
  