catch and throw usage in quicklisp

result.lisp

3bgl-shader/walker.lisp:(defwalker cl-walker (catch tag &rest forms)
3bgl-shader/walker.lisp:  `(catch ,(@ tag) ,@(@@ forms)))
3bgl-shader/walker.lisp:(defwalker cl-walker (throw tag result-form)
3bgl-shader/walker.lisp:  `(throw ,(@ tag) ,(@ result-form)))
3bz/deflate.lisp:          (catch :exit-loop
3bz/deflate.lisp:                    (throw :exit-loop :eoi)))
3bz/deflate.lisp:                    (throw :exit-loop :eoo))))
agnostic-lizard/debugger-prototype.lisp:  (catch 'debugger-hook-result
agnostic-lizard/examples.lisp:         (throw :eval-check-failed "Form expansion changed behaviour")))))
agnostic-lizard/examples.lisp:       (throw :lexenv-check-fail "Form expansion changed behaviour"))))
agnostic-lizard/debugger-hooks.lisp:          ((find op '(throw go return-from))
agnostic-lizard/env-wrappers.lisp:           (throw ',s ,form))))
alexa/src/alexa.lisp:                           (catch ',sentinel
alexa/src/alexa.lisp:                    (throw ',sentinel nil))))
alexandria/tests.lisp:      (catch 'foof
alexandria/tests.lisp:            (throw 'foof 42)
arc-compat/string.arc.lisp:          (when (funcall pat (ref seq i)) (throw i)))
arc-compat/string.arc.lisp:          (when (headmatch pat seq i) (throw i))))
arc-compat/arc.arc.lisp:        (throw index)))))|#
arc-compat/arc.lisp:        (throw index)))))
architecture.hooks/src/hook.lisp:          (catch 'abort-handler
architecture.hooks/src/hook.lisp:               (throw 'abort-handler nil))
architecture.hooks/src/hook.lisp:               (throw 'abort-handler nil))
architecture.hooks/src/hook.lisp:               (throw 'abort-handler nil))
architecture.hooks/src/hook.lisp:               (throw 'abort-handler nil))))))
arnesi/t/walk.lisp:  (is (test-walk '(catch 'done (with-call/cc* (* 2 3)))))
arnesi/t/walk.lisp:  (is (test-walk '(catch 'scheduler
arnesi/t/walk.lisp:  (is (test-walk '(catch 'c
arnesi/t/walk.lisp:		     (catch 'c (c1) (print 'unreachable))
arnesi/t/call-cc.lisp:             (catch 'whatever
arnesi/t/call-cc.lisp:             (catch 'whatever
arnesi/t/call-cc.lisp:               (catch 'done
arnesi/t/call-cc.lisp:             (catch 'done
arnesi/src/unwalk.lisp:  `(catch ,(unwalk-form tag) ,@(unwalk-forms body)))
arnesi/src/walk.lisp:    (with-form-object (catch catch-form :parent parent :source form)
arnesi/src/call-cc/interpreter.lisp:  (catch 'done
arnesi/src/call-cc/handlers.lisp:(defmethod evaluate/cc ((catch catch-form) lex-env dyn-env k)
arnesi/src/call-cc/handlers.lisp:(defk catch-tag-k (catch lex-env dyn-env k)
arnesi/t/walk.lisp:		      (if (done-p) (throw 'scheduler 'done) (go start))))))
arnesi/t/walk.lisp:		   (flet ((c1 () (throw 'c 1)))
arnesi/t/call-cc.lisp:  (throw 'done something))
arnesi/t/call-cc.lisp:               (throw 'whatever t)
arnesi/t/call-cc.lisp:               (throw 'whatever nil)
arnesi/t/call-cc.lisp:                      (throw 'done it)))
arnesi/t/call-cc.lisp:                 (throw 'done 'bad-bad-bad)))))
arnesi/src/unwalk.lisp:  `(throw ,(unwalk-form tag) ,(unwalk-form value)))
arnesi/src/walk.lisp:    (with-form-object (throw throw-form :parent parent :source form)
arnesi/src/call-cc/interpreter.lisp:    (throw 'done (values-list (cons value other-values)))))
arnesi/src/call-cc/apply.lisp:      (throw 'done (values-list (cons value other-values)))))
arnesi/src/call-cc/handlers.lisp:(defmethod evaluate/cc ((throw throw-form) lex-env dyn-env k)
arnesi/src/call-cc/handlers.lisp:(defk throw-tag-k (throw lex-env dyn-env k)
beirc/application.lisp:                 (catch 'keystroke-command
beirc/application.lisp:                                         (throw 'keystroke-command (lookup-keystroke-command-item
binascii/tests/rt.lisp:  (catch '*in-test*
binascii/tests/rt.lisp:	 (if error? (throw '*debug* nil)))
binascii/tests/rt.lisp:      (throw '*in-test* nil)
birch/test/events.lisp:             collect `(ok (eq (catch *result-tag*
birch/test/events.lisp:     (throw *result-tag* ,result)))
bordeaux-threads/test/bordeaux-threads-test.lisp:                                      (catch 'new-thread
bordeaux-threads/src/bordeaux-threads.lisp:           (catch ',ok-tag
bordeaux-threads/src/bordeaux-threads.lisp:             (catch ',timeout-tag
bordeaux-threads/test/bordeaux-threads-test.lisp:                               (throw 'new-thread 'interrupted)))
bordeaux-threads/src/bordeaux-threads.lisp:                                                         (throw ',timeout-tag nil)))))
bordeaux-threads/src/bordeaux-threads.lisp:                 (throw ',ok-tag (progn ,@body))))
cambl/cambl.lisp:    (catch 'stop
cambl/cambl.lisp:             (throw 'stop nil)))))
cells/fm-utilities.lisp:     (let ((matches (catch 'fm-find-all
cells/fm-utilities.lisp:    (let ((match (catch 'fm-find-one
cells/fm-utilities.lisp:                                        (throw 'fm-find-all matches)))))
cells/fm-utilities.lisp:             (throw 'fm-find-one fm))))
chanl/src/actors.lisp:                    (catch :die
chanl/src/actors.lisp:  (:method ((actor actor) (command (eql :die))) (throw :die (current-thread))))
chipz/inflate.lisp:    (catch 'inflate-done
chipz/bzip2.lisp:    (catch 'bzip2-done
chipz/inflate.lisp:                              (throw 'inflate-done nil))
chipz/inflate.lisp:               (throw 'inflate-done t))
chipz/inflate.lisp:                       ((zerop n-copied-bytes) (throw 'inflate-done nil))
chipz/inflate.lisp:                     (inflate-state-output-end state)) (throw 'inflate-done nil))
chipz/inflate.lisp:                   (throw 'inflate-done nil))
chipz/bzip2.lisp:                              (throw 'bzip2-done nil))
chipz/bzip2.lisp:                   (throw 'bzip2-done :ok))
chipz/bzip2.lisp:               (throw 'bzip2-done t))
chipz/types-and-tables.lisp:           (throw 'inflate-done nil))
chtml-matcher/matcher.lisp:      (catch 'found
chtml-matcher/matcher.lisp:       (catch 'found
chtml-matcher/matcher.lisp:	       (throw 'found it)
chtml-matcher/matcher.lisp:		(throw 'found it)
cl-beanstalk/beanstalk.lisp:  `(catch 'done
cl-beanstalk/beanstalk.lisp:       (catch 'retry
cl-beanstalk/beanstalk.lisp:           (throw 'done
cl-beanstalk/beanstalk.lisp:                               (throw 'retry nil))
cl-bibtex/bibtex-runtime.lisp:     (catch 'bib-error 
cl-bibtex/bibtex-runtime.lisp:      (if (catch 'aux-error
cl-bibtex/bibtex-compiler.lisp:	    (catch 'complicated-loop
cl-bibtex/bibtex-runtime.lisp:  (throw 'bib-error nil))
cl-bibtex/bibtex-runtime.lisp:  (throw 'aux-error nil))
cl-bibtex/bibtex-compiler.lisp:	  (throw 'complicated-loop :not-balanced))
cl-bibtex/bibtex-compiler.lisp:	  (throw 'complicated-loop :assignments-in-predicate))
cl-bunny/t/integration/basic.lisp:  ;;              (catch 'stop
cl-bunny/src/connection/iolib-threaded.lisp:         (catch 'stop-connection
cl-bunny/t/integration/connection.lisp:                                   (throw 'bunny::stop-connection nil)))
cl-bunny/t/integration/basic.lisp:  ;;                                      (:finally () (throw 'stop nil))))))
cl-bunny/src/connection/iolib-threaded.lisp:  (throw 'stop-connection (values)))
cl-bunny/src/connection/iolib-threaded.lisp:                         (throw 'stop-connection nil)))))
cl-bunny/src/connection/iolib-threaded.lisp:                              (throw 'stop-connection 'transport-error))
cl-bunny/src/connection/iolib-threaded.lisp:                                                   (throw 'stop-connection nil))
cl-bunny/src/connection/iolib-threaded.lisp:                                                   (throw 'stop-connection nil))
cl-bunny/src/connection/iolib-threaded.lisp:                                (throw 'stop-connection e)))))
cl-bunny/src/connection/iolib-threaded.lisp:  (throw 'stop-connection (values)))
cl-bunny/src/connection/iolib-threaded.lisp:    (throw 'stop-connection (values method))))
cl-cont/test/cases.lisp:           (catch 'a
cl-cont/test/cases.lisp:    (with-call/cc (catch 'foo
cl-cont/test/cases.lisp:    (with-call/cc (catch 'foo
cl-cont/test/cases.lisp:    (catch 'foo (values))))
cl-cont/test/cases.lisp:      (catch 'foo (values 1 2 3)))
cl-cont/test/cases.lisp:    (catch 'foo 'a (throw 'foo (values)) 'c)))
cl-cont/test/cases.lisp:      (catch 'foo 'a (throw 'foo (values 1 2 3)) 'c))
cl-cont/test/cases.lisp:        (catch 'foo
cl-cont/test/cases.lisp:        (catch 'foo
cl-cont/src/special-transformers.lisp:  `(catch ,(cadr cons)
cl-cont/test/cases.lisp:		    1 (throw 'foo 2) 3))
cl-cont/test/cases.lisp:    (catch 'foo 'a (throw 'foo (values)) 'c)))
cl-cont/test/cases.lisp:      (catch 'foo 'a (throw 'foo (values 1 2 3)) 'c))
cl-cont/test/cases.lisp:      (flet ((%f (x) (throw 'foo x)))
cl-cont/test/cases.lisp:      (labels ((%f (x) (throw 'foo x)))
cl-coroutine/t/cl-coroutine.lisp:  (catch 'result
cl-coroutine/t/cl-coroutine.lisp:    (throw 'result 1)
cl-docutils/publisher.lisp:  (catch :skip-siblings
cl-docutils/parsers/rst.lisp:          (catch 'state-machine-eof
cl-docutils/parsers/rst.lisp:        (catch 'state-machine-eof (next-line (state-machine state)))
cl-docutils/parsers/rst.lisp:  (catch 'state-machine-eof (next-line (state-machine state)))
cl-docutils/parsers/rst.lisp:      (unless (catch 'state-machine-eof
cl-docutils/parsers/rst.lisp:    (catch :finished-metadata (call-next-method)))))
cl-docutils/parsers/state-machine.lisp:        (catch 'state-machine-eof
cl-docutils/nodes.lisp:  `(catch :skip-siblings
cl-docutils/nodes.lisp:                (catch :skip-children
cl-docutils/nodes.lisp:                    (catch :skip-siblings
cl-docutils/transforms/parts.lisp:                            (throw :skip-siblings c)))
cl-docutils/transforms/frontmatter.lisp:      (throw :skip-siblings child))))
cl-docutils/parsers/rst.lisp:(throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:        (throw 'state-machine-eof nil)))))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (when (context state) (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:  (throw 'state-machine-eof nil))
cl-docutils/parsers/rst.lisp:                     (throw :finished-metadata *document*))
cl-docutils/parsers/rst.lisp:                     (throw :finished-metadata *document*))))))
cl-docutils/parsers/state-machine.lisp:        (throw 'state-machine-eof nil)
cl-docutils/nodes.lisp:      (when (typep node 'docinfo) (throw :skip-siblings node)))))
cl-factoring/ulimyhmpqs-1.0.lisp:    (catch 'noexist (invmod1 x m))))
cl-factoring/ulimyhmpqs-1.0.lisp:    (catch 'got-them-all (a-generator))))
cl-factoring/ulimyhmpqs-1.0.lisp:             (cond ((= x 0) (throw 'noexist nil))
cl-factoring/ulimyhmpqs-1.0.lisp:      (throw 'got-them-all 
cl-feedparser/parser.lisp:          (catch 'parser-done
cl-feedparser/parser.lisp:         (throw 'parser-done nil))))))
cl-html5-parser/html5-parser.lisp:          while (catch 'please-reparse
cl-html5-parser/inputstream.lisp:    (throw 'please-reparse t)))
cl-jpeg/jpeg.lisp:    (catch 'marker
cl-jpeg/jpeg.lisp:                     (throw 'marker 'restart))
cl-jpeg/jpeg.lisp:                    (t (throw 'marker b2))))))
cl-json/src/camel-case.lisp:                        (catch 'all-caps
cl-json/src/camel-case.lisp:                      (catch 'all-caps
cl-json/src/camel-case.lisp:                     (catch 'all-caps
cl-json/src/camel-case.lisp:                     (catch 'all-caps
cl-json/src/decoder-args.lisp:                        (catch 'all-caps
cl-json/src/decoder-args.lisp:                      (catch 'all-caps
cl-json/src/decoder-args.lisp:                     (catch 'all-caps
cl-json/src/decoder-args.lisp:                     (catch 'all-caps
cl-json/src/camel-case.lisp:      (cond (from-numeric (throw 'all-caps nil))
cl-json/src/camel-case.lisp:          ((:lower :mixed) (throw 'all-caps nil))
cl-json/src/decoder-args.lisp:      (cond (from-numeric (throw 'all-caps nil))
cl-json/src/decoder-args.lisp:          ((:lower :mixed) (throw 'all-caps nil))
cl-llvm/src/core/instruction-builders.lisp:  (then basic-block) (catch basic-block) (name :string))
cl-mathstats/dev/basic-statistics.lisp:      (catch 'recover
cl-mathstats/dev/basic-statistics.lisp:                                             (throw 'recover (values :zero-cell nil nil))))
cl-mathstats/dev/basic-statistics.lisp:                                             (throw 'recover (values :zero-cell nil nil)))))
cl-mime/parse-mime.lisp:  (catch 'bad-mime
cl-mime/parse-mime.lisp:	    ((eof) (throw 'bad-mime nil))
cl-mime/parse-mime.lisp:	    (t (throw 'bad-mime "Unexpected Parse Return Value"))))))
cl-mime/parse-mime.lisp:      ((end-mime eof) (throw 'bad-mime nil))
cl-mime/parse-mime.lisp:      (t (throw 'bad-mime "Unexpected Parse Return Value")))))
cl-mock/src/mock.lisp:      (catch 'unhandled
cl-mock/src/mock.lisp:  (throw 'unhandled (values)))
cl-mw/src/packet-buffer.lisp:               (catch :finished
cl-mw/src/packet-buffer.lisp:               (catch :finished
cl-mw/src/packet-buffer.lisp:                    (throw :finished t))
cl-mw/src/packet-buffer.lisp:                 (throw :finished t)))
cl-mw/src/packet-buffer.lisp:                           (throw :finished t)))
cl-paypal/cl-paypal-test.lisp:  (catch 'stop-server
cl-paypal/cl-paypal-test.lisp:  (throw 'stop-server nil))
cl-pdf/pdf.lisp:    (catch 'max-number-of-pages-reached
cl-pdf/pdf.lisp:      (throw 'max-number-of-pages-reached nil))
cl-prevalence/test/demo2.lisp:      (catch 'trap-overdraw
cl-prevalence/test/demo2.lisp:					    (throw 'trap-overdraw :ignore))))
cl-python/lib/builtins.lisp:	(catch :getattr-block
cl-python/runtime/import.lisp:    (catch 'py-import-retry
cl-python/runtime/classes.lisp:  (catch :getattr-block
cl-python/compiler/generator.lisp:  `(let ((val (catch '.generator-body
cl-python/contrib/lispy.lisp:        (catch 'restart-reading-all-languages
cl-python/runtime/import.lisp:                                         (throw 'py-import-retry nil)) ;; cause unwinding
cl-python/compiler/generator.lisp:  `(throw '.generator-body ,val))
cl-python/contrib/lispy.lisp:                                                             (throw 'restart-reading-all-languages nil)))))
cl-statsd/src/clients/base.lisp:       (catch 'ignore-error
cl-statsd/src/clients/base.lisp:    (throw 'ignore-error nil))
cl-stdutils/src/onlisp.lisp:     (catch *halt* (loop (pick-process)))))
cl-stdutils/src/onlisp.lisp:(defun halt (&optional val) (throw *halt* val))
cl-uglify-js/src/codegen.lisp:                                                                  (catch 'has-call
cl-uglify-js/src/codegen.lisp:                                                                        (:call () (throw 'has-call t))
clawk/clawk.lisp:                    (catch ',nextlbl
clawk/clawk.lisp:                    (catch ',nextlbl
clfswm/src/clfswm-generic-mode.lisp:             (catch exit-tag
clfswm/src/xlib-util.lisp:        (catch 'exit-handle-event
clfswm/src/clfswm-internal.lisp:  (catch 'nw-hook-loop
clfswm/src/clfswm.lisp:  (catch 'exit-main-loop
clfswm/src/clfswm.lisp:    (catch 'exit-clfswm
clfswm/contrib/blank-window-mode.lisp:    (throw 'exit-blank-window-loop nil)))
clfswm/contrib/volume-mode.lisp:    (throw 'exit-volume-loop nil)))
clfswm/src/clfswm-nw-hooks.lisp:      (throw 'nw-hook-loop t)))
clfswm/src/clfswm-second-mode.lisp:	 (throw 'exit-second-loop nil))
clfswm/src/clfswm-info.lisp:  (throw 'exit-info-loop nil))
clfswm/src/clfswm-info.lisp:  (throw 'exit-info-loop nil))
clfswm/src/clfswm-info.lisp:  (throw 'exit-info-loop nil))
clfswm/src/clfswm-fastswitch-mode.lisp:  (throw 'exit-fastswitch-loop nil))
clfswm/src/xlib-util.lisp:  (throw 'exit-handle-event nil))
clfswm/src/xlib-util.lisp:    (throw 'exit-move-window-mode nil))
clfswm/src/xlib-util.lisp:    (throw 'exit-move-window-mode nil))
clfswm/src/xlib-util.lisp:    (throw 'exit-resize-window-mode nil))
clfswm/src/xlib-util.lisp:    (throw 'exit-resize-window-mode nil))
clfswm/src/xlib-util.lisp:  (throw 'exit-wait-mouse-button-release-mode nil))
clfswm/src/clfswm-query.lisp:  (throw 'exit-query-loop nil))
clfswm/src/clfswm-util.lisp:  (throw 'exit-main-loop nil))
clfswm/src/clfswm-circulate-mode.lisp:  (throw 'exit-circulate-loop nil))
clfswm/src/clfswm.lisp:           (throw 'exit-clfswm nil))
clfswm/src/clfswm.lisp:  (throw 'exit-clfswm nil))
clfswm/src/clfswm.lisp:  (throw 'exit-main-loop nil))
clfswm/src/clfswm-expose-mode.lisp:  (throw 'exit-expose-loop nil))
clfswm/src/clfswm-expose-mode.lisp:  (throw 'exit-expose-loop t))
clfswm/src/clfswm-expose-mode.lisp:  (throw 'exit-expose-loop nil))
clfswm/src/clfswm-expose-mode.lisp:  (throw 'exit-expose-loop t))
climacs/c-syntax.lisp:  (throw 'done nil))
climacs/c-syntax.lisp:  (throw 'done nil))
climacs/java-syntax.lisp:  (throw 'done nil))
climacs/java-syntax.lisp:  (throw 'done nil))
closure-html/src/parse/sgml-parse.lisp:  (catch 'read-tag-error
closure-html/src/parse/sgml-parse.lisp:  (throw 'read-tag-error 
clsql-helper/connections.lisp:    (catch *thread-local-transaction-catch-tag*
clsql-helper/connections.lisp:                   (throw *thread-local-transaction-catch-tag* c)
clweb/rt.lisp:  (catch '*in-test*
clweb/rt.lisp:         (if error? (throw '*debug* nil)))
clweb/rt.lisp:      (throw '*in-test* nil)
clx/generalock.lisp:  (catch 'timeout
clx/generalock.lisp:		    (t (throw 'timeout nil))))))
com.clearly-useful.generic-collection-interface/reduceable-base.lisp:  (catch 'coll-reduce
com.clearly-useful.generic-collection-interface/reduceable-base.lisp:  (throw 'coll-reduce v))
com.clearly-useful.protocols/test.lisp:  `(catch 'error-return
com.clearly-useful.protocols/test.lisp:			       (throw 'error-return ,form))))
commonqt/call.lisp:          (catch 'stop-overriding-tag
commonqt/primitive-call.lisp:                             (catch 'stop-overriding-tag
commonqt/meta.lisp:  (throw 'stop-overriding-tag 0))
conium/scl.lisp:          (cond (probe (throw (car probe) (eval-in-frame form index)))
conium/cmucl.lisp:          (cond (probe (throw (car probe) (eval-in-frame form index)))
conium/sbcl.lisp:      (cond (probe (throw (car probe) (eval-in-frame form index)))
cover/cover-test.lisp:  (catch '*in-test*
cover/cover-test.lisp:	 (if error? (throw '*debug* nil)))
cover/cover-test.lisp:      (throw '*in-test* nil)
croatoan/source/croatoan.lisp:  (catch 'event-loop
croatoan/source/form.lisp:  (throw 'event-loop (values nil (list object event args))))
croatoan/source/form.lisp:  (throw 'event-loop (values t (list object event args))))
croatoan/source/croatoan.lisp:Example use: (bind scr #\q  (lambda (win event) (throw 'event-loop :quit)))"
croatoan/source/croatoan.lisp:  (throw 'event-loop :exit-event-loop))
croatoan/source/menu.lisp:  (throw 'event-loop return-value))
csv-parser/csv-parser.lisp:    (catch 'end-of-line
csv-parser/csv-parser.lisp:     (throw 'end-of-line nil))
csv-parser/csv-parser.lisp:     (throw 'end-of-line nil))
csv-parser/csv-parser.lisp:     (throw 'end-of-line nil))
cxml/test/domtest.lisp:(defun translate-catch (catch return)
cxml/test/domtest.lisp:  (catch 'give-up
cxml/test/domtest.lisp:        (throw 'give-up nil)))))
de.setf.wilbur/src/core/rdf-parser.lisp:  (catch :terminate-rdf-parser
eager-future2/make-future.lisp:    (catch 'task-done
eager-future2/future.lisp:  (tagbody (catch 'task-done
eager-future2/future.lisp:                        (catch 'go-select
eager-future2/scheduler.lisp:          (catch 'die
eager-future2/scheduler.lisp:              (loop (catch 'continue
eager-future2/make-future.lisp:                                   (throw 'task-done nil)))))))
eager-future2/make-future.lisp:      (flet ((get-future () (or (weak-pointer-value future-ptr) (throw 'task-done nil))))
eager-future2/make-future.lisp:                (throw 'task-done nil)
eager-future2/future.lisp:                                     (throw 'go-select nil))
eager-future2/future.lisp:                                             (throw 'go-select nil))))))
eager-future2/scheduler.lisp:                                     (throw 'continue nil))))
eager-future2/scheduler.lisp:               (push (lambda () (throw 'die nil)) *task-queue*)
femlisp/src/ddo/utils.lisp:  `(catch 'ddo-error
femlisp/src/basic/tests.lisp:  (catch 'trap
femlisp/src/basic/demo.lisp:  (catch 'quit (show-demo demo))
femlisp/src/basic/demo.lisp:	   (when (catch 'trap
femlisp/src/ddo/utils.lisp:            (throw 'ddo-error (format nil "Error communicated by proc=~D" proc)))))
femlisp/src/ddo/utils.lisp:           (throw 'ddo-error error-message))
femlisp/src/ddo/utils.lisp:           (throw 'ddo-error error-message)))))
femlisp/src/basic/tests.lisp:          #'(lambda (condition) (throw 'trap condition)))
femlisp/src/basic/tests.lisp:          #'(lambda (condition) (throw 'trap condition))))
femlisp/src/basic/demo.lisp:	    (throw 'quit nil))
femlisp/src/basic/demo.lisp:	 ((string-equal line "quit") (throw 'quit nil))
femlisp/src/basic/demo.lisp:		   (handler-bind ((error #'(lambda (condition) (throw 'trap condition)))
femlisp/src/basic/demo.lisp:                                  (warning #'(lambda (condition) (throw 'trap condition))))
fiveam/src/random.lisp:  (catch 'run-once
fiveam/src/random.lisp:              (throw 'run-once
fiveam/src/random.lisp:           (throw 'run-once (list :no-tests)))
fiveam/src/random.lisp:           (throw 'run-once (list :pass)))
fiveam/src/random.lisp:           (throw 'run-once (list :fail values result-list))))))))
fn/mad.lisp:(defhandler catch (catch tag &rest body)
hemlock/src/interp.lisp:                   (catch 'command-loop-catcher
hemlock/src/old-debug.lisp:      (catch 'blow-debug-edit-source
hemlock/src/searchcoms.lisp:      (when (eq (catch 'exit-i-search
hemlock/src/main.lisp:       (catch 'command-loop-catcher     ;fixme: isn't this redundant?
hemlock/src/main.lisp:         (catch 'editor-top-level-catcher
hemlock/src/main.lisp:        (catch 'editor-top-level-catcher
hemlock/src/main.lisp:            (catch 'hemlock-exit
hemlock/src/main.lisp:  (catch 'editor-top-level-catcher
hemlock/src/linedit.lisp:        (catch 'inner-linedit-result
hemlock/src/linedit.lisp:              (catch 'linedit-eof
hemlock/src/linedit.lisp:          (when (eq (catch 'exit-i-search
hemlock/src/streams.lisp:            (catch 'hi::lispbuf-input
hemlock/src/display.lisp:    (catch 'redisplay-catcher
hemlock/src/display.lisp:           (catch 'redisplay-catcher
hemlock/src/display.lisp:  (catch 'redisplay-catcher
hemlock/src/group.lisp:               (catch 'file-not-found
hemlock/src/rompsite.lisp:    (catch 'redisplay-catcher
hemlock/src/dired.lisp:    (catch 'found-file
hemlock/src/kbdmac.lisp:              (catch 'exit-kbdmac
hemlock/src/kbdmac.lisp:                  (catch 'abort-kbdmac-iteration
hemlock/src/kbdmac.lisp:              (catch 'exit-kbdmac
hemlock/src/kbdmac.lisp:                  (catch 'abort-kbdmac-iteration
hemlock/src/kbdmac.lisp:      (catch 'punt-kbdmac
hemlock/src/eval-server.lisp:                     (catch 'abort-operation
hemlock/src/buffer.lisp:                         (catch 'leave-recursive-edit
hemlock/src/buffer.lisp:                               (loop (catch 'editor-top-level-catcher
hemlock/src/interp.lisp:                             (throw 'command-loop-catcher nil)))))
hemlock/src/interp.lisp:  (throw 'hemlock-exit value))
hemlock/src/old-debug.lisp:    (throw 'blow-debug-edit-source nil)))
hemlock/src/tty-display.lisp:      (throw 'redisplay-catcher :editor-input))
hemlock/src/tty-display.lisp:      (throw 'redisplay-catcher :editor-input))
hemlock/src/macros.lisp:                                   (throw 'command-loop-catcher nil)))
hemlock/src/macros.lisp:               (throw 'editor-top-level-catcher nil))
hemlock/src/macros.lisp:      (throw 'editor-top-level-catcher nil))))
hemlock/src/macros.lisp:      (throw 'command-loop-catcher nil))
hemlock/src/macros.lisp:      (throw 'command-loop-catcher nil))
hemlock/src/macros.lisp:      (throw 'command-loop-catcher nil)))))
hemlock/src/searchcoms.lisp:           (throw 'exit-i-search :control-g))
hemlock/src/searchcoms.lisp:         (throw 'exit-i-search nil))
hemlock/src/searchcoms.lisp:         (throw 'exit-i-search nil))))
hemlock/src/linedit.lisp:      (throw 'inner-linedit-result (get-string (current-device)))
hemlock/src/linedit.lisp:        (throw 'linedit-eof nil))
hemlock/src/linedit.lisp:           (throw 'exit-i-search :control-g))
hemlock/src/linedit.lisp:         (throw 'exit-i-search nil))
hemlock/src/linedit.lisp:         (throw 'exit-i-search nil))))
hemlock/src/input.lisp:      (throw 'editor-top-level-catcher nil))
hemlock/src/input.lisp:           (throw 'more-punt nil))
hemlock/src/input.lisp:           (throw 'more-punt nil)))))
hemlock/src/input.lisp:      (throw 'editor-top-level-catcher nil))
hemlock/src/lispbuf.lisp:          (throw 'hi::lispbuf-input
hemlock/src/display.lisp:        (throw 'redisplay-catcher :editor-input))
hemlock/src/display.lisp:            (throw 'redisplay-catcher :editor-input))
hemlock/src/group.lisp:    (throw 'file-not-found nil))
hemlock/src/dired.lisp:            (unless find-all-p (throw 'found-file t)))))))
hemlock/src/kbdmac.lisp:  (throw 'punt-kbdmac ()))
hemlock/src/kbdmac.lisp:         (throw 'exit-kbdmac nil))
hemlock/src/kbdmac.lisp:         (throw 'abort-kbdmac-iteration nil))
hemlock/src/kbdmac.lisp:         (throw 'exit-kbdmac nil))))))
hemlock/src/buffer.lisp:  (throw 'leave-recursive-edit (values :exit values)))
hemlock/src/buffer.lisp:  (throw 'leave-recursive-edit (values :abort args)))
hunchensocket/hunchensocket.lisp:          (catch 'websocket-done
hunchensocket/hunchensocket.lisp:                                      (throw 'websocket-done nil))))
hunchentoot/request.lisp:  (catch 'request-processed ; used by HTTP HEAD handling to end request processing in a HEAD request (see START-OUTPUT)
hunchentoot/request.lisp:                     (catch 'handler-done
hunchentoot/headers.lisp:      (throw 'request-processed nil))
hunchentoot/misc.lisp:  (throw 'handler-done result))
hunchentoot/misc.lisp:        (throw 'handler-done
hunchentoot/acceptor.lisp:                    (throw 'handler-done
inner-conditional/lib/macroexpand-dammit.lisp:(defhandler catch (catch tag &rest body)
iterate/iterate.lisp:    (catch . 		    walk-cdr)
iterate/iterate.lisp:	((catch if locally multiple-value-call multiple-value-prog1
iterate/iterate.lisp:    (throw . 		    walk-cdr) 
js-parser/external/rt.lisp:  (catch '*in-test*
js-parser/src/parse-javascript.lisp:  ((catch :catch :left-paren :identifier :right-paren block) (make-catch-clause :binding $$3 :body (statement-block-statements $5) :start $s :end $e))
js-parser/external/rt.lisp:         (if error? (throw '*debug* nil)))
js-parser/external/rt.lisp:    (throw '*in-test* nil)
js/api.lisp:         (catch 'err
js/runtime.lisp:                              (catch 'maybe-int
js/runtime.lisp:                                     (catch 'maybe-int (date-from-milliseconds (maybe-int val))))))
js/runtime.lisp:                              (t (catch 'maybe-int
js/api.lisp:                      (setf continue t) (throw 'err nil))
js/api.lisp:                      (format t "! ~a~%" (to-string (js-condition-value e))) (throw 'err nil)))))
js/api.lisp:               (throw 'err nil))))
js/runtime.lisp:                     (throw 'maybe-int nil)
jwacs/external/rt.lisp:  (catch '*in-test*
jwacs/parse-javascript.lisp:  ((catch :catch :left-paren :identifier :right-paren block) (make-catch-clause :binding $$3 :body (statement-block-statements $5) :start $s :end $e))
jwacs/external/rt.lisp:         (if error? (throw '*debug* nil)))
jwacs/external/rt.lisp:    (throw '*in-test* nil)
kenzo/archive/Kenzo-8/homology-groups.lisp:  (catch '?
kenzo/archive/Kenzo-9/homology-groups.lisp:  (catch '?
kenzo/src/kenzo-8/homology-groups.lisp:  (catch '?
kenzo/src/kenzo-7/homology-groups.lisp:  (catch '?
kenzo/src/kenzo-9/homology-groups.lisp:  (catch '?
kenzo/archive/Kenzo-8/homology-groups.lisp:         ((eq ptl fin) (throw '? nil))
kenzo/archive/Kenzo-8/homology-groups.lisp:            (if (= min 1) (throw '? pmin))
kenzo/archive/Kenzo-8/homology-groups.lisp:                ((eq ptl fin) (throw '? pmin))
kenzo/archive/Kenzo-8/homology-groups.lisp:                    (if (= val 1) (throw '? pl))
kenzo/archive/Kenzo-9/homology-groups.lisp:         ((eq ptl fin) (throw '? nil))
kenzo/archive/Kenzo-9/homology-groups.lisp:            (if (= min 1) (throw '? pmin))
kenzo/archive/Kenzo-9/homology-groups.lisp:                ((eq ptl fin) (throw '? pmin))
kenzo/archive/Kenzo-9/homology-groups.lisp:                    (if (= val 1) (throw '? pl))
kenzo/src/kenzo-8/homology-groups.lisp:         ((eq ptl fin) (throw '? nil))
kenzo/src/kenzo-8/homology-groups.lisp:            (if (= min 1) (throw '? pmin))
kenzo/src/kenzo-8/homology-groups.lisp:                ((eq ptl fin) (throw '? pmin))
kenzo/src/kenzo-8/homology-groups.lisp:                    (if (= val 1) (throw '? pl))
kenzo/src/kenzo-7/homology-groups.lisp:         ((eq ptl fin) (throw '? nil))
kenzo/src/kenzo-7/homology-groups.lisp:            (if (= min 1) (throw '? pmin))
kenzo/src/kenzo-7/homology-groups.lisp:                ((eq ptl fin) (throw '? pmin))
kenzo/src/kenzo-7/homology-groups.lisp:                    (if (= val 1) (throw '? pl))
kenzo/src/kenzo-9/homology-groups.lisp:         ((eq ptl fin) (throw '? nil))
kenzo/src/kenzo-9/homology-groups.lisp:            (if (= min 1) (throw '? pmin))
kenzo/src/kenzo-9/homology-groups.lisp:                ((eq ptl fin) (throw '? pmin))
kenzo/src/kenzo-9/homology-groups.lisp:                    (if (= val 1) (throw '? pl))
lift/dev/test-runner.lisp:    (catch :test-end
lift/timeout/with-timeout.lisp:       (catch ',glabel
lift/timeout/with-timeout.lisp:             (throw ',glabel nil)))
linedit/main.lisp:           (catch 'linedit-done
linedit/main.lisp:		(catch 'linedit-loop
linedit/main.lisp:    (catch 'form-done
linedit/command-functions.lisp:  (throw 'linedit-done t))
linedit/command-functions.lisp:  (throw 'linedit-loop t))
linedit/main.lisp:		 (throw 'form-done str)))))))))
lisp-binary/utils.lisp:						     (catch ',catch-tag
lisp-binary/utils.lisp:									     (throw ',catch-tag ',catch-tag)))))
lisp-binary/utils.lisp:								     (throw ',catch-tag ',catch-tag))))
lisp-executable/src/creation-cmucl.lisp:  (throw 'lisp::%end-of-the-world exit-status))
lisp-matrix/src/unittests/unittests.lisp:              (throw 'run-once
lispbuilder/lispbuilder-clawk/clawk.lisp:                    (catch ',nextlbl
lispbuilder/lispbuilder-clawk/clawk.lisp:                    (catch ',nextlbl
lispbuilder/lispbuilder-regex/regex.lisp:      (catch 'cease-matching
lispbuilder/lispbuilder-regex/regex.lisp:;           (catch 'cease-matching
lispbuilder/lispbuilder-regex/regex.lisp:;             (catch 'cease-matching
lispbuilder/lispbuilder-regex/regex.lisp:  (let ((result (catch 'regex-parse-error
lispbuilder/lispbuilder-regex/regex.lisp:  (let ((result (catch 'regex-parse-error
lispbuilder/lispbuilder-regex/closure.lisp:         (if (catch 'cease-matching (funcall childfn pos))
lispbuilder/lispbuilder-regex/closure.lisp:         (if (not (catch 'cease-matching (funcall childfn pos)))
lispbuilder/lispbuilder-regex/optimize.lisp:      (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/optimize.lisp:      (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/optimize.lisp:      (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:                      (throw 'regex-parse-error (list "Invalid character class"))))
lispbuilder/lispbuilder-regex/parser.lisp:                      (throw 'regex-parse-error (list "Invalid character class"))))
lispbuilder/lispbuilder-regex/parser.lisp:      (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:        (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:                            (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:                              (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:                (t (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:    (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:            (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:    (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:    (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:   (t (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/parser.lisp:      (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/gen.lisp:      (throw 'regex-parse-error
lispbuilder/lispbuilder-regex/closure.lisp:            (throw 'cease-matching
lparallel/src/kernel/kill.lisp:  `(catch +worker-suicide-tag+
lparallel/src/kernel/handling.lisp:    `(catch +current-task+
lparallel/src/kernel/kill.lisp:            (throw +worker-suicide-tag+ nil)))))
lparallel/src/kernel/kill.lisp:        (throw +worker-suicide-tag+ nil)))))
lparallel/src/kernel/handling.lisp:    (throw +current-task+ (wrap-error err))))
lsx/reader.lisp:                               (catch 'end-of-tag
lsx/reader.lisp:       (throw 'end-of-tag *reading-tag-children*))
ltk/ltk/ltk.lisp:		     (catch wish (main-iteration :blocking nil)))))
ltk/ltk/ltk.lisp:      (catch *wish*
ltk/ltk/ltk.lisp:         (catch 'modal-toplevel
ltk/ltk/ltk-remote.lisp:  (catch 'exit-with-remote-ltk
ltk/ltk/ltk.lisp:    (throw 'exit-with-remote-ltk nil))
ltk/ltk/ltk.lisp:  (throw *wish* nil))
ltk/ltk/ltk.lisp:      (throw 'modal-toplevel nil)))
mcclim/Core/clim-core/gadgets.lisp:          (catch 'popup-list-box-done
mcclim/Apps/Scigraph/scigraph/menu-tools.lisp:           (catch :abort
mcclim/Apps/Scigraph/scigraph/moving-object.lisp:	(catch 'abort
mcclim/Apps/Scigraph/dwim/present.lisp:       (catch ',normal
mcclim/Apps/Scigraph/dwim/present.lisp:	 (catch 'catch-parser-failures
mcclim/Apps/Listener/dev-commands.lisp:                (catch 'done
mcclim/Lisp-Dep/mp-sbcl.lisp:     (catch 'interrupted-wait (sb-thread:with-mutex (*permanent-queue*))))))
mcclim/Libraries/Drei/lr-syntax.lisp:      (catch 'done
mcclim/Examples/gadget-test.lisp:  (catch 'exit
mcclim/Examples/gadget-test-kr.lisp:  (catch 'exit
mcclim/Core/clim-core/gadgets.lisp:                   (throw 'popup-list-box-done nil)))
mcclim/Apps/Scigraph/scigraph/moving-object.lisp:		     (button-case button :middle (throw 'abort nil)))
mcclim/Apps/Scigraph/scigraph/moving-object.lisp:		       :middle (throw 'abort nil)
mcclim/Apps/Scigraph/scigraph/moving-object.lisp:		       :middle (throw 'abort nil)
mcclim/Apps/Scigraph/dwim/present.lisp:				     (throw 'catch-parser-failures t))))
mcclim/Apps/Scigraph/dwim/present.lisp:	     (throw ',normal ,form)))
mcclim/Apps/Scigraph/dwim/present.lisp:      (throw 'catch-parser-failures t))
mcclim/Apps/Listener/dev-commands.lisp:                                                                   (throw 'done result)))))))))
mcclim/Lisp-Dep/mp-sbcl.lisp:   (process-thread process) (lambda () (throw 'interrupted-wait nil))))
mcclim/Libraries/Drei/lisp-syntax.lisp:  (throw 'done nil))
mcclim/Libraries/Drei/lisp-syntax.lisp:  (throw 'done nil))
metatilities-base/dev/generic-interface.lisp:  `(catch 'recover
metatilities-base/dev/generic-interface.lisp:  (catch :cancel
metatilities-base/dev/l0-macros.lisp:    `(catch ',catch-tag
metatilities-base/dev/generic-interface.lisp:                                 (throw 'recover NIL)))
metatilities-base/dev/l0-macros.lisp:       (flet ((:resume () (throw ',catch-tag 0))
metatilities/dev/contrib/mcl/appearance-mcl.lisp:                (catch (page-truncation-tag view)
metatilities/dev/utilities/searching.lisp:      (throw :a*-terminated (values :terminated paths))))
metatilities/dev/mcl/generic-interface-support.lisp:      (throw :cancel (values result index))
mgl-pax/test/test-transcribe.lisp:          (catch 'here
mgl-pax/test/test-transcribe.lisp:                     (throw 'here nil))))
mtlisp/ctrace.lisp:     (catch :ctrace-err
mtlisp/ctrace.lisp:                     (throw :ctrace-err *ctrace-top*))))
named-readtables/test/rt.lisp:  (catch '*in-test*
named-readtables/test/rt.lisp:         (if error? (throw '*debug* nil)))
named-readtables/test/rt.lisp:      (throw '*in-test* nil)
nodgui/src/nodgui.lisp:                     (catch wish (main-iteration :blocking nil)))))
nodgui/src/nodgui.lisp:      (catch *wish*
nodgui/src/nodgui.lisp:         (catch 'modal-toplevel
nodgui/src/trivial-debugger.lisp:      (throw 'modal-toplevel nil)))
nodgui/src/wish-communication.lisp:    (throw 'exit-with-remote-nodgui nil))
nodgui/src/wish-communication.lisp:  (throw *wish* nil))
paiprolog/othello.lisp:    (catch 'game-over
paiprolog/prologc.lisp:  (catch 'top-level-prove
paiprolog/prologc.lisp:      (throw 'top-level-prove nil)))
petalisp/code/native-backend/worker-pool.lisp:                 (catch 'join-thread
petalisp/code/native-backend/worker-pool.lisp:     (throw 'join-thread nil))
pg/utility.lisp:    (catch 'pg-finished
plump/parser.lisp:    (catch close-tag
plump/special-tags.lisp:      (throw tag NIL)))
portable-threads/test/portable-threads-test.lisp:    (catch :not-held
portable-threads/test/portable-threads-test.lisp:        (catch :held
portable-threads/test/portable-threads-test.lisp:                                 (catch 'throwable-sleep-nearly-forever
portable-threads/test/portable-threads-test.lisp:                      (catch 'awaken (sleep-nearly-forever))
portable-threads/scheduled-periodic-functions.lisp:         (catch 'kill-periodic-function
portable-threads/portable-threads.lisp:    `(catch ',tag-sym
portable-threads/portable-threads.lisp:       (catch ',tag-sym
portable-threads/portable-threads.lisp:    `(catch ',tag-sym
portable-threads/portable-threads.lisp:    `(catch ',tag-sym
portable-threads/portable-threads.lisp:    `(catch ',tag-sym
portable-threads/portable-threads.lisp:    `(catch ',tag-sym
portable-threads/portable-threads.lisp:  (catch tag (sleep-nearly-forever))
portable-threads/test/portable-threads-test.lisp:              (throw :held nil)))
portable-threads/test/portable-threads-test.lisp:        (throw :not-held nil)))
portable-threads/test/portable-threads-test.lisp:                              (throw 'awaken nil)))
portable-threads/scheduled-periodic-functions.lisp:          (throw 'kill-periodic-function nil))
portable-threads/portable-threads.lisp:                          (throw ',tag-sym
portable-threads/portable-threads.lisp:                       (throw ',tag-sym
portable-threads/portable-threads.lisp:                          (throw ',tag-sym
portable-threads/portable-threads.lisp:                          (throw ',tag-sym
portable-threads/portable-threads.lisp:                        (throw ',tag-sym
portable-threads/portable-threads.lisp:                              (throw ',tag-sym
portable-threads/portable-threads.lisp:          #'(lambda () (ignore-errors (throw tag nil))))
portableaserve/acl-compat/lispworks/acl-mp.lisp:      (catch timeout-cons
portableaserve/acl-compat/lispworks/acl-mp.lisp:        do (throw timeout-cons
prepl/debug.lisp:       (catch 'debug-loop-catcher
prepl/prepl.lisp:      (catch 'repl-catcher
prepl/inspect.lisp:  (throw 'repl-catcher (values :inspect nil)))
prepl/commands.lisp:        (throw 'repl-catcher cmd)
prepl/commands.lisp:     (throw 'repl-catcher (values :inspect n)))
prepl/commands.lisp:     (throw 'repl-catcher (values :pop n))))
prepl/commands.lisp:	    (throw 'repl-catcher (values :pop 1)))
prepl/debug.lisp:                      (throw 'debug-loop-catcher nil))))
prepl/debug.lisp:                                   (throw 'debug-loop-catcher nil)))))
prepl/debug.lisp:       (throw 'repl-catcher (values :debug :exit))
prepl/prepl.lisp:      (throw 'repl-catcher :no-reason))))
projectured/source/editor/editor.lisp:  (catch :quit-editor
projectured/source/editor/operation.lisp:  (throw :quit-editor nil))
qooxlisp/cl-json_0.4.0/src/camel-case.lisp:                        (catch 'all-caps
qooxlisp/cl-json_0.4.0/src/camel-case.lisp:                      (catch 'all-caps
qooxlisp/cl-json_0.4.0/src/camel-case.lisp:                     (catch 'all-caps
qooxlisp/cl-json_0.4.0/src/camel-case.lisp:                     (catch 'all-caps
qooxlisp/cl-json_0.4.0/src/decoder-args.lisp:                        (catch 'all-caps
qooxlisp/cl-json_0.4.0/src/decoder-args.lisp:                      (catch 'all-caps
qooxlisp/cl-json_0.4.0/src/decoder-args.lisp:                     (catch 'all-caps
qooxlisp/cl-json_0.4.0/src/decoder-args.lisp:                     (catch 'all-caps
qooxlisp/qx-utils.lisp:  `(catch 'excl::printer-error
qooxlisp/utilities.lisp:  `(catch 'excl::printer-error
qooxlisp/apropos/utilities.lisp:  `(catch 'excl::printer-error
qooxlisp/cl-json_0.4.0/src/camel-case.lisp:      (cond (from-numeric (throw 'all-caps nil))
qooxlisp/cl-json_0.4.0/src/camel-case.lisp:          ((:lower :mixed) (throw 'all-caps nil))
qooxlisp/cl-json_0.4.0/src/decoder-args.lisp:      (cond (from-numeric (throw 'all-caps nil))
qooxlisp/cl-json_0.4.0/src/decoder-args.lisp:          ((:lower :mixed) (throw 'all-caps nil))
quilc/src/addresser/addresser-common.lisp:  (catch 'dry-run-succeeded
quilc/src/addresser/addresser-common.lisp:                                (lambda () (throw 'dry-run-succeeded t))
qvm/app/src/impl/clozure.lisp:               (catch 'done
qvm/app/src/impl/sbcl.lisp:               (catch 'done
qvm/app/src/shm-info-server.lisp:                           (throw 'done t)))))
racer/source/timeout.lisp:	     (catch ',tag-sym
racer/source/timeout.lisp:    (catch tag
racer/source/timeout.lisp:    (catch tag
racer/source/timeout.lisp:        (catch tag
racer/source/timeout.lisp:    (catch tag
racer/source/timeout.lisp:        (catch tag
racer/source/data-substrate.lisp:              (catch 'found
racer/source/data-substrate.lisp:               (catch 'found
racer/source/preparation.lisp:                              (catch 'query-execution 
racer/source/preparation.lisp:                              (catch 'query-execution 
racer/source/query-optimizer.lisp:             (catch 'not-rewritable
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:              (catch :cant-render
racer/source/functional-renderer.lisp:  `(catch :cant-render
racer/source/expressions.lisp:                                 (catch :return-from-dolist
racer/source/expressions.lisp:                                 (catch :return-from-dolist
racer/source/racer-server.lisp:		     (catch :abort
racer/source/racer-server.lisp:		 (catch :abort
racer/source/racer-server.lisp:	       (catch :abort
racer/source/compiler.lisp:      `(catch 'abort-enumerator
racer/source/compiler.lisp:      (catch 'abort-enumerator
racer/source/compiler.lisp:    `(catch 'abort-enumerator
racer/source/compiler.lisp:    (catch 'abort-enumerator
racer/source/compiler.lisp:        `(catch 'abort-enumerator
racer/source/compiler.lisp:        `(catch 'abort-enumerator
racer/source/compiler.lisp:          `(catch 'abort-enumerator
racer/source/compiler.lisp:        `(catch 'abort-enumerator
racer/source/compiler.lisp:        (catch 'abort-enumerator
racer/source/compiler.lisp:        (catch 'abort-enumerator
racer/source/compiler.lisp:          (catch 'abort-enumerator
racer/source/compiler.lisp:        (catch 'abort-enumerator
racer/source/tracer.lisp:  (catch :cancel
racer/source/owllink-interface.lisp:       (catch 'language
racer/source/owllink-interface.lisp:	 (catch 'language
racer/source/owllink-interface.lisp:    (catch 'language
racer/source/models.lisp:    (catch 'cyclic-model-found
racer/source/models.lisp:  (catch 'cyclic-model-found
racer/source/rdf-parser.lisp:  (catch :terminate-rdf-parser
racer/source/timeout.lisp:				   (throw ',tag-sym
racer/source/timeout.lisp:                                   (throw tag
racer/source/timeout.lisp:                             (throw tag
racer/source/timeout.lisp:	      (throw tag
racer/source/timeout.lisp:	      (throw tag
racer/source/timeout.lisp:                                       (throw tag 
racer/source/timeout.lisp:                                 (throw tag
racer/source/timeout.lisp:                                   (throw tag
racer/source/timeout.lisp:            (abort-execution () (throw tag
racer/source/timeout.lisp:                                       (throw tag 
racer/source/timeout.lisp:                                 (throw tag
racer/source/abduction.lisp:  ;;; (throw 'query-execution 'done)
racer/source/abduction.lisp:                (throw 'query-execution 'done)))))))))
racer/source/macros.lisp:     (throw 'query-execution 'abort)))
racer/source/data-substrate.lisp:                                          (throw 'found succ)))))
racer/source/data-substrate.lisp:                                           (throw 'found succ)))))
racer/source/query-optimizer.lisp:      (otherwise (throw 'not-rewritable concept-name)))))
racer/source/caching-code.lisp:         (throw 'abort-enumerator t)))))
racer/source/caching-code.lisp:        (throw 'abort-enumerator t)))))
racer/source/caching-code.lisp:             (throw 'abort-enumerator t))))
racer/source/caching-code.lisp:           (throw 'abort-enumerator t))))))
racer/source/caching-code.lisp:          (throw 'abort-enumerator t)))
racer/source/caching-code.lisp:          (throw 'abort-enumerator t))))))
racer/source/caching-code.lisp:           (throw 'abort-enumerator t))))))
racer/source/caching-code.lisp:          (throw 'abort-enumerator t))))))
racer/source/caching-code.lisp:           (throw 'abort-enumerator t))))))
racer/source/caching-code.lisp:          (throw 'abort-enumerator t))))))
racer/source/functional-renderer.lisp:                (throw :cant-render *catch-return*))
racer/source/expressions.lisp:                          (throw :return-from-dolist 
racer/source/compiler.lisp:  (throw 'query-execution 'done))
racer/source/compiler.lisp:                     (throw 'query-execution 'done)))))))))
racer/source/compiler.lisp:             (throw 'abort-enumerator t)))))))
racer/source/compiler.lisp:            (throw 'abort-enumerator t)))))))
racer/source/abox-queries-code.lisp:                 (throw 'abort-enumerator t)))))
racer/source/abox-queries-code.lisp:                                                           (throw 'abort-enumerator t)))))
racer/source/abox-queries-code.lisp:                   (throw 'abort-enumerator t)))))))
racer/source/abox-queries-code.lisp:             (throw 'abort-enumerator t)))))))
racer/source/abox-queries-code.lisp:              (throw 'abort-enumerator t)))
racer/source/abox-queries-code.lisp:                                                          (throw 'abort-enumerator t))))
racer/source/abox-queries-code.lisp:                (throw 'abort-enumerator t)))))
racer/source/abox-queries-code.lisp:            (throw 'abort-enumerator t)))))))
racer/source/abox-queries-code.lisp:           (throw 'abort-enumerator t))))))
racer/source/abox-queries-code.lisp:      (throw 'abort-enumerator t))))
racer/source/owllink-interface.lisp:            (throw 'language :rdf-xml))
racer/source/owllink-interface.lisp:            (throw 'language :owl-xml))
racer/source/owllink-interface.lisp:            (throw 'language :owl-xml))
racer/source/owllink-interface.lisp:            (throw 'language :owl-xml))
racer/source/owllink-interface.lisp:            (throw 'language :owllink))
racer/source/owllink-interface.lisp:           (t (throw 'language :dont-know))))
racer/source/owllink-interface.lisp:          (throw 'language :dont-know))))
racer/source/models.lisp:    (throw 'cyclic-model-found (values nil t))
racer/source/progress.lisp:	 (throw :abort nil))
regex/regex.lisp:      (catch 'cease-matching
regex/regex.lisp:  (let ((result (catch 'regex-parse-error
regex/regex.lisp:  (let ((result (catch 'regex-parse-error
regex/optimize.lisp:      (throw 'regex-parse-error
regex/optimize.lisp:      (throw 'regex-parse-error
regex/optimize.lisp:      (throw 'regex-parse-error
regex/parser.lisp:      (throw 'regex-parse-error
regex/parser.lisp:        (throw 'regex-parse-error
regex/parser.lisp:                            (throw 'regex-parse-error
regex/parser.lisp:                              (throw 'regex-parse-error
regex/parser.lisp:                (t (throw 'regex-parse-error
regex/parser.lisp:    (throw 'regex-parse-error
regex/parser.lisp:            (throw 'regex-parse-error
regex/parser.lisp:    (throw 'regex-parse-error
regex/parser.lisp:    (throw 'regex-parse-error
regex/parser.lisp:   (t (throw 'regex-parse-error
regex/parser.lisp:      (throw 'regex-parse-error
regex/gen.lisp:      (throw 'regex-parse-error
regex/closure.lisp:            (throw 'cease-matching
restas/src/route.lisp:         (response (catch 'route-done
restas/src/route.lisp:  (throw 'route-done obj))
roan/method-tests.lisp:               (catch 'too-long
roan/method-tests.lisp:      (throw 'too-long nil))
rutils/core/iter.lisp:    (catch .                walk-cdr)
rutils/core/iter.lisp:        ((catch if locally multiple-value-call multiple-value-prog1
rutils/core/iter.lisp:    (throw .                walk-cdr)
scalpl/actor.lisp:      (catch :halt (perform actor)))))
scalpl/actor.lisp:  (:method ((actor actor) (command (eql :halt))) (throw :halt actor)))
screamer/screamer.lisp:  `(catch '%fail
screamer/screamer.lisp:  `(catch 'succeed
screamer/screamer.lisp:           (throw 'succeed value))))))
screamer/screamer.lisp:                     (throw '%fail nil)
scriptl/src/server.lisp:      `(catch ',unhandled-error
scriptl/src/server.lisp:                          (catch 'error-handled
scriptl/src/scriptl-v1.lisp:                            (catch 'unhandled
scriptl/src/scriptl-v2.lisp:                         (catch 'unhandled
scriptl/src/server.lisp:                  (throw ',unhandled-error t))))
scriptl/src/scriptl-v1.lisp:                                  (throw 'unhandled nil)))
scriptl/src/scriptl-v1.lisp:                              (throw 'error-handled nil))))))
scriptl/src/scriptl-v2.lisp:                             (throw 'unhandled nil))
scriptl/src/scriptl-v2.lisp:                           (throw 'error-handled nil))))))
sequence-iterators/extensible-sequences/tests/rt.lisp:  (catch '*in-test*
sequence-iterators/tests/rt.lisp:  (catch '*in-test*
sequence-iterators/extensible-sequences/tests/rt.lisp:         (if error? (throw '*debug* nil)))
sequence-iterators/extensible-sequences/tests/rt.lisp:      (throw '*in-test* nil)
sequence-iterators/tests/rt.lisp:         (if error? (throw '*debug* nil)))
sequence-iterators/tests/rt.lisp:      (throw '*in-test* nil)
serapeum/internal-definitions.lisp:    (catch 'local
serapeum/trees.lisp:               (catch tag
serapeum/trees.lisp:               (catch tag
serapeum/internal-definitions.lisp:                  (throw 'local
serapeum/tests/trees.lisp:                             (throw 'skip 'skipped)
serapeum/trees.lisp:FUN can skip the current subtree with (throw TAG nil)."
serapeum/trees.lisp:FUN can skip the current subtree with (throw TAG SUBTREE), in which
series/s-code.lisp:  `(cl:let ((,res (catch :series-restriction-violation (starting-series-expr ,call ,opt))))
series/s-test.lisp:  (catch '*in-test*
series/s-test.lisp:	 (opt (catch :testing-errors (test-opt form)))
series/s-test.lisp:	 (non-opt (catch :testing-errors (test-non-opt form))))
series/s-test.lisp:    (catch :testing-errors (test-opt form))))
series/s-code.lisp:    (throw :testing-errors id))
series/s-code.lisp:  (throw :series-restriction-violation nil))
series/s-test.lisp:	 (if error? (throw '*debug* nil)))
series/s-test.lisp:      (throw '*in-test* nil)
shellpool/test/kill.lisp:         (result (catch 'simulated-interrupt
shellpool/test/kill.lisp:                              (throw 'simulated-interrupt *my-interrupt*))
shuffletron/src/util.lisp:      `(with-input-from-string (in ,string) (catch 'fail ,@body))
shuffletron/src/util.lisp:      `(catch 'fail ,@body)))
shuffletron/src/util.lisp:(defun val (x) (or x (throw 'fail nil)))
single-threaded-ccl/single-threaded-ccl.lisp:  (catch :flushing-rep-eof
single-threaded-ccl/single-threaded-ccl.lisp:      (throw :flushing-rep-eof nil))
slime/swank.lisp:  (catch 'exit-sentinel
slime/contrib/swank-listener-hooks.lisp:	for res =  (catch *slime-repl-eval-hook-pass*
slime/contrib/swank-mrepl.lisp:	   (catch tag (process-requests nil))
slime/contrib/swank-macrostep.lisp:  (catch *macrostep-tag*
slime/swank.lisp:    (throw 'exit-sentinel nil)))
slime/swank/scl.lisp:          (cond (probe (throw (car probe) (eval-in-frame form index)))
slime/swank/cmucl.lisp:          (cond (probe (throw (car probe) (eval-in-frame form index)))
slime/swank/sbcl.lisp:      (cond (probe (throw (car probe) (eval-in-frame form index)))
slime/sbcl-pprint-patch.lisp:	(throw 'line-limit-abbreviation-happened t))
slime/contrib/swank-listener-hooks.lisp:  (throw *slime-repl-eval-hook-pass* *slime-repl-eval-hook-pass*))
slime/contrib/swank-mrepl.lisp:    (throw tag string)))
slime/contrib/swank-macrostep.lisp:  (throw *macrostep-tag* (macroexpand-1 form env)))
slime/contrib/swank-macrostep.lisp:  (throw *macrostep-tag* (collect-macro-forms form env)))
smackjack/smackjack.lisp:                          (throw (new (*error "XMLHttpRequest not supported")))))
sly/slynk/slynk.lisp:  (catch 'exit-sentinel
sly/slynk/slynk.lisp:  (catch 'stop-processing
sly/contrib/slynk-mrepl.lisp:                      (catch 'mrepl-read (process-requests nil))
sly/slynk/backend/scl.lisp:          (cond (probe (throw (car probe) (eval-in-frame form index)))
sly/slynk/backend/cmucl.lisp:          (cond (probe (throw (car probe) (eval-in-frame form index)))
sly/slynk/backend/sbcl.lisp:      (cond (probe (throw (car probe) (eval-in-frame form index)))
sly/slynk/slynk.lisp:      (throw 'stop-processing 'listener-teardown)
sly/slynk/slynk.lisp:    (throw 'exit-sentinel nil)))
sly/contrib/slynk-mrepl.lisp:      (:read (throw 'mrepl-read string))
snark/src/main.lisp:        (catch 'fail
snark/src/main.lisp:      (catch 'fail
snark/src/main.lisp:   (catch 'fail
snark/src/main.lisp:   (catch 'fail
snark/src/main.lisp:    (catch 'fail
snark/src/main.lisp:    (catch 'fail
snark/src/main.lisp:    (catch 'fail
snark/src/main.lisp:    (catch 'fail
snark/src/main.lisp:      (catch 'fail
snark/src/main.lisp:    (catch 'fail
snark/src/main.lisp:      (catch 'fail
snark/src/main.lisp:      (catch 'fail
snark/src/input.lisp:    ((catch 'needs-strict-polarity
snark/src/input.lisp:    ((catch 'needs-strict-polarity
snark/src/input.lisp:    ((catch 'needs-strict-polarity
snark/src/subsume.lisp:    (catch 'subsumed
snark/src/subsume.lisp:  (catch 'subsumed
snark/src/unify-bag.lisp:    (catch 'unify-bag-basis-quit
snark/src/term-hash.lisp:    (catch 'hash-term-not-found
snark/src/main.lisp:  (throw 'fail nil))
snark/src/main.lisp:      (throw 'fail nil)
snark/src/main.lisp:      (throw 'fail nil)
snark/src/main.lisp:      (throw 'fail nil)
snark/src/main.lisp:      (throw 'fail nil))))
snark/src/main.lisp:      (throw 'fail nil)
snark/src/input.lisp:    (throw 'needs-strict-polarity nil))
snark/src/subsume.lisp:            (throw 'subsumed t)))
snark/src/subsume.lisp:          (throw 'subsumed t))))
snark/src/subsume.lisp:	   (throw 'subsumed t)))
snark/src/subsume.lisp:	 (throw 'subsumed t))))))
snark/src/jepd-relations.lisp:    (throw 'needs-strict-polarity nil))
snark/src/unify-bag.lisp:     (throw 'unify-bag-basis-quit
snark/src/unify-bag.lisp:      (throw 'unify-bag-basis-quit nil))
snark/src/unify-bag.lisp:	(dotimes (j nycoefs (throw 'unify-bag-basis-quit nil))
snark/src/unify-bag.lisp:	(dotimes (i nxcoefs (throw 'unify-bag-basis-quit nil))
snark/src/term-hash.lisp:	(throw 'hash-term-not-found none))
snooze/common.lisp:  (catch 'response
snooze/common.lisp:             (throw 'response
snooze/common.lisp:          (throw 'response
snooze/common.lisp:                    (throw 'response (values code
specialization-store/src/lambda-lists.lisp:  (catch 'ordinary-lambda-list-error
staple/parser/special-forms.lisp:(define-walker-form (catch tag . body) (cst)
staple/parser/special-forms.lisp:(define-walker-form (throw tag result) (cst)
stumpwm/command.lisp:  (catch 'error
stumpwm/input.lisp:      (catch :abort
stumpwm/menu-definitions.lisp:  (catch :menu-quit
stumpwm/stumpwm.lisp:      (let ((ret (catch :top-level
stumpwm/command.lisp:      (throw 'error :abort)))
stumpwm/command.lisp:      (throw 'error :abort)))
stumpwm/command.lisp:             (throw 'error \"Abort.\")))
stumpwm/command.lisp:     (throw 'error \"Symbol not in STUMPWM package\")))
stumpwm/command.lisp:      (throw 'error "Too many :'s"))
stumpwm/command.lisp:        (throw 'error (format nil "No such symbol: ~a::~a."
stumpwm/command.lisp:        (throw 'error (format nil "The symbol ~A::~A is not bound to any function."
stumpwm/command.lisp:      (throw 'error "No Such Window."))))
stumpwm/command.lisp:        (throw 'error "Number required.")))))
stumpwm/command.lisp:        (throw 'error "No matching direction."))))
stumpwm/command.lisp:        (throw 'error "No matching gravity."))))
stumpwm/command.lisp:        (throw 'error "No Such Group."))))
stumpwm/command.lisp:        (throw 'error "Frame not found."))
stumpwm/command.lisp:        (throw 'error :abort))))
stumpwm/command.lisp:                         (throw 'error (format nil "Command '~a' not found." command))))
stumpwm/command.lisp:                                (throw 'error (format nil "Bad argument type: ~s" type)))
stumpwm/command.lisp:        (throw 'error (format nil "Trailing garbage: ~{~A~^ ~}" (subseq (argument-line-string arg-line)
stumpwm/command.lisp:      (throw 'error :abort))
stumpwm/window.lisp:      (throw 'error :abort))
stumpwm/user.lisp:          (throw 'error :abort))
stumpwm/user.lisp:  (throw :top-level :quit))
stumpwm/user.lisp:  (throw :top-level :restart))
stumpwm/user.lisp:  (throw :top-level :hup-process))
stumpwm/input.lisp:  (throw :abort nil))
stumpwm/input.lisp:       (throw :abort t))
stumpwm/menu-definitions.lisp:  (throw :menu-quit (nth (menu-selected menu) (menu-table menu))))
stumpwm/menu-definitions.lisp:      (throw :menu-quit alist))))
stumpwm/menu-definitions.lisp:  (throw :menu-quit nil))
stumpwm/remap-keys.lisp:                 (throw 'error
stumpwm/stumpwm.lisp:     (throw :top-level :quit))
stumpwm/stumpwm.lisp:     (throw :top-level (list c (backtrace-string))))))
stumpwm/tile-window.lisp:              (throw 'error :abort))))))
stumpwm/group.lisp:    (throw 'error :abort))
stumpwm/group.lisp:    (throw 'error :abort))
sucle/application/app-subsystem/application/application.lisp:     (catch *quit-token*
sucle/application/app-subsystem/application/application.lisp:     (throw *quit-token* ,form)))
toot/http.lisp:  (catch 'head-request
toot/http.lisp:      (throw 'head-request nil))
trees/rt.lisp:  (catch '*in-test*
trees/rt.lisp:	 (if error? (throw '*debug* nil)))
trees/rt.lisp:      (throw '*in-test* nil)
trivia/level1/impl.lisp:;;         ((lambda (x) (if last? x `(catch 'next ,x)))
trivia/level1/impl.lisp:;; (defun next () (throw 'next nil))
trivial-irc/examples/echobot/echobot.lisp:  (catch 'stop
trivial-irc/examples/echobot/echobot.lisp:		       (throw 'stop nil)))))
trivial-shell/timeout/with-timeout.lisp:       (catch ',glabel
trivial-shell/timeout/with-timeout.lisp:             (throw ',glabel nil)))
trivial-timeout/dev/with-timeout.lisp:       (catch ',glabel
trivial-timeout/dev/with-timeout.lisp:             (throw ',glabel nil)))
ucw/src/rerl/basic-action.lisp:       (catch 'abort-raw-request
ucw/src/components/dojo-widgets.lisp:               (throw message))))
ucw/src/rerl/basic-action.lisp:     (throw 'abort-raw-request nil)))
weblocks-stores/src/store/elephant/elephant.lisp:           (catch 'finish-map
weblocks-stores/src/store/elephant/elephant.lisp:        (catch 'finish-map
weblocks-stores/src/store/elephant/elephant.lisp:                      (throw 'finish-map nil))
weblocks/test/request.lisp:      (catch 'hunchentoot::handler-done
weblocks/test/request.lisp:      (catch 'hunchentoot::handler-done
weblocks/test/request-handler.lisp:        (catch 'hunchentoot::handler-done
weblocks/test/request-handler.lisp:          (catch 'hunchentoot::handler-done
weblocks/test/request-handler.lisp:        (catch 'hunchentoot::handler-done
weblocks/test/request-handler.lisp:      (catch 'hunchentoot::handler-done
weblocks/test/request-handler.lisp:      (catch 'hunchentoot::handler-done
weblocks/test/request-handler.lisp:        (catch 'hunchentoot::handler-done
weblocks/test/request-handler.lisp:        (catch 'hunchentoot::handler-done
weblocks/test/request-handler.lisp:          (catch 'hunchentoot::handler-done
weblocks/src/utils/misc.lisp:     (catch 'abort-widget-rendering
weblocks/src/widgets/dataform.lisp:                                  (catch 'annihilate-dataform
weblocks/contrib/nunb/replaceable-grid.lisp:                  (throw 'annihilate-dataform nil))
weblocks/contrib/s11001001/dataedit.lisp:                       (throw 'annihilate-dataform nil)))))
weblocks/src/widgets/quickform.lisp:                               (throw 'annihilate-dataform nil))
weblocks/src/widgets/quickform.lisp:                              (throw 'annihilate-dataform nil))
weblocks/src/widgets/gridedit.lisp:                  (throw 'annihilate-dataform nil))
weblocks/src/widgets/gridedit.lisp:                   (throw 'annihilate-dataform nil))
weblocks/src/widgets/gridedit.lisp:                                     (throw 'annihilate-dataform nil))
weblocks/src/widgets/gridedit.lisp:                                (throw 'annihilate-dataform nil)))
weblocks/src/widgets/listedit.lisp:                               (throw 'annihilate-dataform nil))))
zacl/portable-process.lisp:             (catch 'killed
zacl/portable-process.lisp:                      (lambda () (throw 'killed nil))))

run.sh

#!/bin/bash

mkdir -p repos

export SHELL=/bin/bash
task (){
    export name=$(basename $(dirname $1))
    command=$(cat $1)
    cd repos
    $command
}
export -f task

extract (){
    grep -r --include="*.lisp" "(catch " $1
    grep -r --include="*.lisp" "(throw " $1
}
export -f extract

git-clone (){
    $(which git) clone --depth 1 $@
}
export -f git-clone

git (){
    [ -d $name ] || git-clone $1 $name &>/dev/null
    extract $name
}
export -f git

latest-github-tag (){
    [ -d $name ] || git-clone $1 $name &>/dev/null
    extract $name
}
export -f latest-github-tag

latest-github-release (){
    [ -d $name ] || git-clone $1 $name &>/dev/null
    extract $name
}
export -f latest-github-release

branched-git (){
    [ -d $name ] || git-clone -b $2 $1 $name &>/dev/null
    extract $name
}
export -f branched-git

tagged-git (){
    [ -d $name ] || git-clone -b $2 $1 $name &>/dev/null
    extract $name
}
export -f tagged-git

mercurial (){
    [ -d $name ] || hg clone $1 $name &>/dev/null
    extract $name
}
export -f mercurial

https (){
    if ! [ -d $name ]
    then
        curl -s $1  &>/dev/null
        tar xf $(basename $1) &>/dev/null
    fi
    extract $name
}
export -f https

http (){
    if ! [ -d $name ]
    then
        curl -s $1  &>/dev/null
        tar xf $(basename $1) &>/dev/null
    fi
    extract $name
}
export -f http

ediware-http (){
    [ -d $name ] || git-clone https://github.com/edicl/$1.git $name &>/dev/null
    extract $name
}
export -f ediware-http

svn (){
    [ -d $name ] || svn co $1 $name &>/dev/null
    extract $name
}
export -f svn

single-file (){
    if ! [ -d $name ]
    then
        mkdir $name  &>/dev/null
        curl $1 > $name/$(basename $1)  &>/dev/null
    fi
    extract $name
}
export -f single-file

parallel task ::: quicklisp-projects/projects/*/source.txt