util.lisp

(defun write-fixnum (i &optional (stream *standard-output*))
  (declare (optimize (speed 3)))
  (declare (type fixnum i)
           (type stream stream))
  (if (= i 0)
      (write-char #\0 stream)
    (let ((weight (let ((x 1))
                    (declare (type (integer 0 #.(truncate most-positive-fixnum 10)) x))
                    (loop
                      (when (>= x i)
                        (return x))
                      (locally
                        (declare (fixnum x))
                        (setq x (* x 10))))))
          (j i))
      (declare (fixnum j))
      (loop
        (when (= weight 0)
          (return))
        (multiple-value-bind (d ni)
            (floor j weight)
          (if (or (/= d 0)
                  (/= i j))
              (write-char (digit-char d) stream))
          (setq j ni
                weight (truncate weight 10)))))))

(defun glob (string pattern)
  (declare (optimize (speed 3)))
  (declare (simple-string string pattern))
  (labels ((helper (i j)
             ;;(declare (type (integer 0 8192) i j))
             (declare (type fixnum i j))
             (loop
               (let ((c (if (< i (length string)) (elt string i) nil))
                     (p (if (< j (length pattern)) (elt pattern j) nil)))
                 ;;(format t "~A ~A~%" c p)
                 (cond
                  ((and c (or (eql c p) (eql p #\?)))
                   )
                  ((eql c p)
                   (return-from glob t))
                  ((null c)
                   (return-from helper nil))
                  ((eql p #\*)
                   (if (< j (length pattern))
                       (loop :for k :from i :to (length string)
                             :do (helper k (1+ j)))
                     t))
                  (t
                   (return-from helper nil))))
               (when (< i (length string))
                 (incf i))
               (when (< j (length string))
                 (incf j)))))
    (helper 0 0)))