In MacOS debugger invoked when *threads* > 0

[gwangjinkim]

=====================================================

problem "u2" successfully solved.

=====================================================

All problems successfully solved.

T
* *threads*
0
* (setf *threads* 3)
3
* (run-all)
=====================================================

starting to analyze "array-path"

=====================================================

To load "alexandria":
  Load 1 ASDF system:
    alexandria
; Loading "alexandria"

To load "iterate":
  Load 1 ASDF system:
    iterate
; Loading "iterate"

To load "lparallel":
  Load 1 ASDF system:
    lparallel
; Loading "lparallel"

Installing object types...
Installing dynamic relations...
Installing static relations...
Installing MOVE-RIGHT action...
Installing MOVE-LEFT action...
Installing MOVE-DOWN action...
Installing MOVE-UP action...
Creating initial propositional database...

; file: /Users/josephus/.roswell/local-projects/status_wouldwork/src/ww-searcher.lisp
; in: DEFUN SEARCH-SERIAL
;     (ITERATE:ITER
;       (WHEN (HSTACK::EMPTY-HSTACK WOULDWORK::*OPEN*) (ITERATE:LEAVE))
;       (ITERATE:FOR WOULDWORK::SUCC-NODES = (WOULDWORK::DF-BNB1 WOULDWORK::*OPEN*))
;       (WHEN (EQUAL WOULDWORK::SUCC-NODES '(FIRST))
;         (RETURN-FROM WOULDWORK::SEARCH-SERIAL 'FIRST))
;       (WHEN WOULDWORK::SUCC-NODES
;         (IF (FBOUNDP 'WOULDWORK::HEURISTIC?)
;             (SETF WOULDWORK::SUCC-NODES #)
;             (WHEN WOULDWORK::*RANDOMIZE-SEARCH* (SETF #))))
;       (WHEN (= WOULDWORK::*PROGRAM-CYCLES* 0)
;         (WHEN (>= WOULDWORK::*BRANCH* 0)
;           (FORMAT T "~&Exploring only branch ~D of ~D~%" WOULDWORK::*BRANCH*
;                   (LENGTH WOULDWORK::SUCC-NODES))
;           (SETF WOULDWORK::SUCC-NODES #))
;         (SETF WOULDWORK::*NUM-INIT-SUCCESSORS* (LENGTH WOULDWORK::SUCC-NODES))
;         (SETF WOULDWORK::*REM-INIT-SUCCESSORS* (REVERSE WOULDWORK::SUCC-NODES)))
;       (LOOP ITERATE:FOR WOULDWORK::SUCC-NODE ITERATE:IN WOULDWORK::SUCC-NODES
;             DO (HSTACK::PUSH-HSTACK WOULDWORK::SUCC-NODE WOULDWORK::*OPEN*))
;       (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*PROGRAM-CYCLES* 1)
;       (SETF WOULDWORK::*AVERAGE-BRANCHING-FACTOR*
;               (WOULDWORK::COMPUTE-AVERAGE-BRANCHING-FACTOR))
;       (WOULDWORK::PRINT-SEARCH-PROGRESS)
;       (ITERATE:AFTER-EACH))
; 
; caught ERROR:
;   during macroexpansion of
;   (ITER
;     (WHEN # #)
;     (FOR SUCC-NODES = ...)
;     ...).
;   Use *BREAK-ON-SIGNALS* to intercept.
;   
;    Invalid first argument to ATOMIC-INCF: *PROGRAM-CYCLES*

; in: DEFUN DF-BNB1
;     (ITERATE:ITER
;       (WHEN (>= WOULDWORK::*DEBUG* 3)
;         (FORMAT T
;                 "~&-----------------------------------------------------------~%")
;         (FORMAT T "~%Current node selected:~%~S~2%" WOULDWORK::CURRENT-NODE))
;       (WHEN (NULL WOULDWORK::CURRENT-NODE) (RETURN-FROM WOULDWORK::DF-BNB1 NIL))
;       (WHEN
;           (AND (> WOULDWORK::*DEPTH-CUTOFF* 0)
;                (= (WOULDWORK::NODE.DEPTH WOULDWORK::CURRENT-NODE)
;                   WOULDWORK::*DEPTH-CUTOFF*))
;         (WOULDWORK::NARRATE "State at max depth"
;                             (WOULDWORK::NODE.STATE WOULDWORK::CURRENT-NODE)
;                             (WOULDWORK::NODE.DEPTH WOULDWORK::CURRENT-NODE))
;         (RETURN-FROM WOULDWORK::DF-BNB1 NIL))
;       (WHEN
;           (EQL (WOULDWORK::BOUNDING-FUNCTION WOULDWORK::CURRENT-NODE)
;                'WOULDWORK::KILL-NODE)
;         (RETURN-FROM WOULDWORK::DF-BNB1 NIL))
;       (WHEN (EQL WOULDWORK::*TREE-OR-GRAPH* 'WOULDWORK::GRAPH)
;         (SETF (GETHASH # WOULDWORK::*CLOSED*) (LIST # # #)))
;       (LET ((WOULDWORK::SUCC-STATES (WOULDWORK::EXPAND WOULDWORK::CURRENT-NODE)))
;         (WHEN WOULDWORK::*TROUBLESHOOT-CURRENT-NODE*
;           (SETF WOULDWORK::*DEBUG* 5)
;           (SETF WOULDWORK::*TROUBLESHOOT-CURRENT-NODE* NIL)
;           (ITERATE:NEXT-ITERATION))
;         (WHEN (NULL WOULDWORK::SUCC-STATES)
;           (WOULDWORK::UPDATE-MAX-DEPTH-EXPLORED
;            (WOULDWORK::NODE.DEPTH WOULDWORK::CURRENT-NODE))
;           (WOULDWORK::NARRATE "No successor states"
;                               (WOULDWORK::NODE.STATE WOULDWORK::CURRENT-NODE)
;                               (WOULDWORK::NODE.DEPTH WOULDWORK::CURRENT-NODE))
;           (WOULDWORK::FINALIZE-PATH-DEPTH
;            (WOULDWORK::NODE.DEPTH WOULDWORK::CURRENT-NODE))
;           (RETURN-FROM WOULDWORK::DF-BNB1 NIL))
;         (WOULDWORK::UPDATE-MAX-DEPTH-EXPLORED
;          (1+ (WOULDWORK::NODE.DEPTH WOULDWORK::CURRENT-NODE)))
;         (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*TOTAL-STATES-PROCESSED*
;                                      (LENGTH WOULDWORK::SUCC-STATES))
;         (RETURN-FROM WOULDWORK::DF-BNB1
;           (WOULDWORK::PROCESS-SUCCESSORS WOULDWORK::SUCC-STATES
;                                          WOULDWORK::CURRENT-NODE))))
; 
; caught ERROR:
;   during macroexpansion of
;   (ITER
;     (WHEN # # ...)
;     (WHEN # #)
;     ...).
;   Use *BREAK-ON-SIGNALS* to intercept.
;   
;    Invalid first argument to ATOMIC-INCF: *TOTAL-STATES-PROCESSED*

; in: DEFUN PROCESS-SUCCESSORS
;     (ITERATE:ITER
;       (ITERATE:WITH WOULDWORK::SUCC-DEPTH =
;        (1+ (WOULDWORK::NODE.DEPTH WOULDWORK::CURRENT-NODE)))
;       (ITERATE:FOR WOULDWORK::SUCC-STATE ITERATE:IN WOULDWORK::SUCC-STATES)
;       (WHEN
;           (AND WOULDWORK::*SOLUTIONS*
;                (MEMBER WOULDWORK::*SOLUTION-TYPE*
;                        '(WOULDWORK::MIN-LENGTH WOULDWORK::MIN-TIME
;                          WOULDWORK::MIN-VALUE WOULDWORK::MAX-VALUE)))
;         (UNLESS
;             (WOULDWORK::F-VALUE-BETTER WOULDWORK::SUCC-STATE
;                                        WOULDWORK::SUCC-DEPTH)
;           (ITERATE:NEXT-ITERATION)))
;       (WHEN (WOULDWORK::GOAL WOULDWORK::SUCC-STATE)
;         (WOULDWORK::REGISTER-SOLUTION WOULDWORK::CURRENT-NODE
;                                       WOULDWORK::SUCC-STATE)
;         (WOULDWORK::FINALIZE-PATH-DEPTH WOULDWORK::SUCC-DEPTH)
;         (IF (EQL WOULDWORK::*SOLUTION-TYPE* 'FIRST)
;             (RETURN-FROM WOULDWORK::PROCESS-SUCCESSORS '(FIRST))
;             (ITERATE:NEXT-ITERATION)))
;       (UNLESS (BOUNDP 'WOULDWORK::GOAL-FN)
;         (WOULDWORK::PROCESS-MIN-MAX-VALUE WOULDWORK::SUCC-STATE))
;       (WHEN
;           (AND (EQL WOULDWORK::*TREE-OR-GRAPH* 'WOULDWORK::TREE)
;                (EQL WOULDWORK::*PROBLEM-TYPE* 'WOULDWORK::PLANNING))
;         (WHEN
;             (WOULDWORK::ON-CURRENT-PATH WOULDWORK::SUCC-STATE
;                                         WOULDWORK::CURRENT-NODE)
;           (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*REPEATED-STATES*)
;           (WOULDWORK::FINALIZE-PATH-DEPTH WOULDWORK::SUCC-DEPTH)
;           (ITERATE:NEXT-ITERATION)))
;       (WHEN (EQL WOULDWORK::*TREE-OR-GRAPH* 'WOULDWORK::GRAPH)
;         (LET ((WOULDWORK::OPEN-NODE #))
;           (WHEN WOULDWORK::OPEN-NODE
;             (WOULDWORK::NARRATE "State already on open" WOULDWORK::SUCC-STATE
;                                 WOULDWORK::SUCC-DEPTH)
;             (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*REPEATED-STATES*)
;             (IF #
;                 #
;                 #)
;             (ITERATE:NEXT-ITERATION)))
;         (LET* ((WOULDWORK::SUCC-IDB #) (WOULDWORK::CLOSED-VALUES #))
;           (WHEN WOULDWORK::CLOSED-VALUES
;             (WOULDWORK::NARRATE "State previously closed" WOULDWORK::SUCC-STATE
;                                 WOULDWORK::SUCC-DEPTH)
;             (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*REPEATED-STATES*)
;             (IF #
;                 #
;                 #))))
;       (ITERATE:COLLECTING
;        (WOULDWORK::GENERATE-NEW-NODE WOULDWORK::CURRENT-NODE
;                                      WOULDWORK::SUCC-STATE)))
; 
; caught ERROR:
;   during macroexpansion of
;   (ITER
;     (WITH SUCC-DEPTH = ...)
;     (FOR SUCC-STATE IN ...)
;     ...).
;   Use *BREAK-ON-SIGNALS* to intercept.
;   
;    Invalid first argument to ATOMIC-INCF: *REPEATED-STATES*

;     (DEFUN WOULDWORK::PROCESS-SUCCESSORS
;            (WOULDWORK::SUCC-STATES WOULDWORK::CURRENT-NODE)
;       (ITERATE:ITER
;         (ITERATE:WITH WOULDWORK::SUCC-DEPTH =
;          (1+ (WOULDWORK::NODE.DEPTH WOULDWORK::CURRENT-NODE)))
;         (ITERATE:FOR WOULDWORK::SUCC-STATE ITERATE:IN WOULDWORK::SUCC-STATES)
;         (WHEN (AND WOULDWORK::*SOLUTIONS* (MEMBER WOULDWORK::*SOLUTION-TYPE* '#))
;           (UNLESS
;               (WOULDWORK::F-VALUE-BETTER WOULDWORK::SUCC-STATE
;                                          WOULDWORK::SUCC-DEPTH)
;             (ITERATE:NEXT-ITERATION)))
;         (WHEN (WOULDWORK::GOAL WOULDWORK::SUCC-STATE)
;           (WOULDWORK::REGISTER-SOLUTION WOULDWORK::CURRENT-NODE
;                                         WOULDWORK::SUCC-STATE)
;           (WOULDWORK::FINALIZE-PATH-DEPTH WOULDWORK::SUCC-DEPTH)
;           (IF (EQL WOULDWORK::*SOLUTION-TYPE* 'FIRST)
;               (RETURN-FROM WOULDWORK::PROCESS-SUCCESSORS '#)
;               (ITERATE:NEXT-ITERATION)))
;         (UNLESS (BOUNDP 'WOULDWORK::GOAL-FN)
;           (WOULDWORK::PROCESS-MIN-MAX-VALUE WOULDWORK::SUCC-STATE))
;         (WHEN
;             (AND (EQL WOULDWORK::*TREE-OR-GRAPH* 'WOULDWORK::TREE)
;                  (EQL WOULDWORK::*PROBLEM-TYPE* 'WOULDWORK::PLANNING))
;           (WHEN
;               (WOULDWORK::ON-CURRENT-PATH WOULDWORK::SUCC-STATE
;                                           WOULDWORK::CURRENT-NODE)
;             (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*REPEATED-STATES*)
;             (WOULDWORK::FINALIZE-PATH-DEPTH WOULDWORK::SUCC-DEPTH)
;             (ITERATE:NEXT-ITERATION)))
;         (WHEN (EQL WOULDWORK::*TREE-OR-GRAPH* 'WOULDWORK::GRAPH)
;           (LET (#)
;             (WHEN WOULDWORK::OPEN-NODE # # # #))
;           (LET* (# #)
;             (WHEN WOULDWORK::CLOSED-VALUES # # #)))
;         (ITERATE:COLLECTING
;          (WOULDWORK::GENERATE-NEW-NODE WOULDWORK::CURRENT-NODE
;                                        WOULDWORK::SUCC-STATE))))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA WOULDWORK::PROCESS-SUCCESSORS
;         (WOULDWORK::SUCC-STATES WOULDWORK::CURRENT-NODE)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       (BLOCK WOULDWORK::PROCESS-SUCCESSORS
;         (ITERATE:ITER
;           (ITERATE:WITH WOULDWORK::SUCC-DEPTH = (1+ #))
;           (ITERATE:FOR WOULDWORK::SUCC-STATE ITERATE:IN WOULDWORK::SUCC-STATES)
;           (WHEN (AND WOULDWORK::*SOLUTIONS* #) (UNLESS # #))
;           (WHEN (WOULDWORK::GOAL WOULDWORK::SUCC-STATE)
;             (WOULDWORK::REGISTER-SOLUTION WOULDWORK::CURRENT-NODE
;                                           WOULDWORK::SUCC-STATE)
;             (WOULDWORK::FINALIZE-PATH-DEPTH WOULDWORK::SUCC-DEPTH)
;             (IF #
;                 #
;                 #))
;           (UNLESS (BOUNDP 'WOULDWORK::GOAL-FN)
;             (WOULDWORK::PROCESS-MIN-MAX-VALUE WOULDWORK::SUCC-STATE))
;           (WHEN (AND # #) (WHEN # # # #))
;           (WHEN (EQL WOULDWORK::*TREE-OR-GRAPH* 'WOULDWORK::GRAPH)
;             (LET #
;               #)
;             (LET* #
;               #))
;           (ITERATE:COLLECTING
;            (WOULDWORK::GENERATE-NEW-NODE WOULDWORK::CURRENT-NODE
;                                          WOULDWORK::SUCC-STATE)))))
; 
; caught STYLE-WARNING:
;   The variable SUCC-STATES is defined but never used.
; 
; caught STYLE-WARNING:
;   The variable CURRENT-NODE is defined but never used.

; in: DEFUN UPDATE-MAX-DEPTH-EXPLORED
;     (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*MAX-DEPTH-EXPLORED*
;                                  (- WOULDWORK::SUCC-DEPTH
;                                     WOULDWORK::*MAX-DEPTH-EXPLORED*))
; ==>
;   (ATOMIC-INCF WOULDWORK::*MAX-DEPTH-EXPLORED*
;                (- WOULDWORK::SUCC-DEPTH WOULDWORK::*MAX-DEPTH-EXPLORED*))
; 
; caught ERROR:
;   during macroexpansion of (ATOMIC-INCF *MAX-DEPTH-EXPLORED* (- SUCC-DEPTH *MAX-DEPTH-EXPLORED*)). Use *BREAK-ON-SIGNALS* to intercept.
;   
;    Invalid first argument to ATOMIC-INCF: *MAX-DEPTH-EXPLORED*

; in: DEFUN FINALIZE-PATH-DEPTH
;     (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*ACCUMULATED-DEPTHS* WOULDWORK::DEPTH)
; ==>
;   (ATOMIC-INCF WOULDWORK::*ACCUMULATED-DEPTHS* WOULDWORK::DEPTH)
; 
; caught ERROR:
;   during macroexpansion of (ATOMIC-INCF *ACCUMULATED-DEPTHS* DEPTH). Use *BREAK-ON-SIGNALS* to intercept.
;   
;    Invalid first argument to ATOMIC-INCF: *ACCUMULATED-DEPTHS*

;     (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*NUM-PATHS* 1)
; ==>
;   (ATOMIC-INCF WOULDWORK::*NUM-PATHS* 1)
; 
; caught ERROR:
;   during macroexpansion of (ATOMIC-INCF *NUM-PATHS* 1). Use *BREAK-ON-SIGNALS* to intercept.
;   
;    Invalid first argument to ATOMIC-INCF: *NUM-PATHS*

;     (DEFUN WOULDWORK::FINALIZE-PATH-DEPTH (WOULDWORK::DEPTH)
;       "Records the path depth of a path that terminates."
;       (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*ACCUMULATED-DEPTHS*
;                                    WOULDWORK::DEPTH)
;       (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*NUM-PATHS* 1))
; --> SB-IMPL::%DEFUN SB-IMPL::%DEFUN SB-INT:NAMED-LAMBDA 
; ==>
;   #'(SB-INT:NAMED-LAMBDA WOULDWORK::FINALIZE-PATH-DEPTH
;         (WOULDWORK::DEPTH)
;       (DECLARE (SB-C::TOP-LEVEL-FORM))
;       "Records the path depth of a path that terminates."
;       (BLOCK WOULDWORK::FINALIZE-PATH-DEPTH
;         (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*ACCUMULATED-DEPTHS*
;                                      WOULDWORK::DEPTH)
;         (WOULDWORK::INCREMENT-GLOBAL WOULDWORK::*NUM-PATHS* 1)))
; 
; caught STYLE-WARNING:
;   The variable DEPTH is defined but never used.

Backtrace for: #<SB-THREAD:THREAD tid=259 "main thread" RUNNING {70050E0393}>
0: ((FLET SB-THREAD::WITH-MUTEX-THUNK :IN "/Users/josephus/.roswell/local-projects/status_wouldwork/src/ww-settings.lisp"))
1: ((FLET "WITHOUT-INTERRUPTS-BODY-" :IN SB-THREAD::CALL-WITH-MUTEX))
2: (SB-THREAD::CALL-WITH-MUTEX #<FUNCTION (FLET SB-THREAD::WITH-MUTEX-THUNK :IN "/Users/josephus/.roswell/local-projects/status_wouldwork/src/ww-settings.lisp") {104D9157B}> #<SB-THREAD:MUTEX "Anonymous lock" taken owner=main thread>)
3: ((LAMBDA (CONDITION ORIGINAL-HOOK) :IN "/Users/josephus/.roswell/local-projects/status_wouldwork/src/ww-settings.lisp") #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {7008F0EA33}> #<unused argument>)
4: (SB-DEBUG::RUN-HOOK *DEBUGGER-HOOK* #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {7008F0EA33}>)
5: (INVOKE-DEBUGGER #<UIOP/LISP-BUILD:COMPILE-FILE-ERROR {7008F0EA33}>)
6: (ERROR UIOP/LISP-BUILD:COMPILE-FILE-ERROR :CONTEXT-FORMAT "~/asdf-action::format-action/" :CONTEXT-ARGUMENTS ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "wouldwork" "src" "ww-searcher">)))
7: (UIOP/LISP-BUILD:CHECK-LISP-COMPILE-RESULTS NIL T T "~/asdf-action::format-action/" ((#<ASDF/LISP-ACTION:COMPILE-OP > . #<ASDF/LISP-ACTION:CL-SOURCE-FILE "wouldwork" "src" "ww-searcher">)))
8: ((SB-PCL::EMF ASDF/ACTION:PERFORM) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "wouldwork" "src" "ww-searcher">)
9: ((LAMBDA NIL :IN ASDF/ACTION:CALL-WHILE-VISITING-ACTION))
10: ((:METHOD ASDF/ACTION:PERFORM-WITH-RESTARTS :AROUND (T T)) #<ASDF/LISP-ACTION:COMPILE-OP > #<ASDF/LISP-ACTION:CL-SOURCE-FILE "wouldwork" "src" "ww-searcher">) [fast-method]
11: ((:METHOD ASDF/PLAN:PERFORM-PLAN (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {7004F80153}>) [fast-method]
12: ((FLET SB-C::WITH-IT :IN SB-C::%WITH-COMPILATION-UNIT))
13: ((:METHOD ASDF/PLAN:PERFORM-PLAN :AROUND (T)) #<ASDF/PLAN:SEQUENTIAL-PLAN {7004F80153}>) [fast-method]
14: ((:METHOD ASDF/OPERATE:OPERATE (ASDF/OPERATION:OPERATION ASDF/COMPONENT:COMPONENT)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "wouldwork"> :PLAN-CLASS NIL :PLAN-OPTIONS NIL) [fast-method]
15: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "wouldwork"> :FORCE T)
16: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
17: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) #<ASDF/LISP-ACTION:LOAD-OP > #<ASDF/SYSTEM:SYSTEM "wouldwork"> :FORCE T) [fast-method]
18: ((SB-PCL::EMF ASDF/OPERATE:OPERATE) #<unused argument> #<unused argument> ASDF/LISP-ACTION:LOAD-OP :WOULDWORK :FORCE T)
19: ((LAMBDA NIL :IN ASDF/OPERATE:OPERATE))
20: (ASDF/SESSION:CALL-WITH-ASDF-SESSION #<FUNCTION (LAMBDA NIL :IN ASDF/OPERATE:OPERATE) {7004F8009B}> :OVERRIDE NIL :KEY NIL :OVERRIDE-CACHE NIL :OVERRIDE-FORCING NIL)
21: ((:METHOD ASDF/OPERATE:OPERATE :AROUND (T T)) ASDF/LISP-ACTION:LOAD-OP :WOULDWORK :FORCE T) [fast-method]
22: (ASDF/OPERATE:LOAD-SYSTEM :WOULDWORK :FORCE T)
23: (RELOAD-WITH-NEW-PROBLEM "array-path" "problem.lisp" :WOULDWORK)
24: (RUN-TEST-PROBLEMS "problem.lisp" 3)
25: (SB-INT:SIMPLE-EVAL-IN-LEXENV (RUN-ALL) #<NULL-LEXENV>)
26: (EVAL (RUN-ALL))
27: (INTERACTIVE-EVAL (RUN-ALL) :EVAL NIL)
28: (SB-IMPL::REPL-FUN NIL)
29: ((LAMBDA NIL :IN SB-IMPL::TOPLEVEL-REPL))
30: (SB-IMPL::%WITH-REBOUND-IO-SYNTAX #<FUNCTION (LAMBDA NIL :IN SB-IMPL::TOPLEVEL-REPL) {104D9048B}>)
31: (SB-IMPL::TOPLEVEL-REPL NIL)
32: (SB-IMPL::TOPLEVEL-INIT)
33: ((FLET SB-UNIX::BODY :IN SB-IMPL::START-LISP))
34: ((FLET "WITHOUT-INTERRUPTS-BODY-3" :IN SB-IMPL::START-LISP))
35: (SB-IMPL::%START-LISP)

COMPILE-FILE-ERROR while compiling #<CL-SOURCE-FILE "wouldwork" "src" "ww-searcher">

; 
; compilation unit aborted
;   caught 1 fatal ERROR condition
;   caught 6 ERROR conditions
;   caught 3 STYLE-WARNING conditions
Installing goal...

error when threads is not 0 in SBCL at least. The error doesn't disappear when :SBCL removed from features

[gwangjinkim]

By the way - we should work with Docker containers - to test

you from Windows Linux and me from Mac Linux (and possibly Windows).

Docker container for MacOS do not exist I guess. But when things in Linux work, then usually it is not that different in MacOS. And if, then these are smaller deviations I guess.

[gwangjinkim]

If you do:

> git branch
  main
* permanent-global-vars

the new branch's name where I put the global variable permanent feature is in the branch "permanent-global-vars"

You can switch it on by:

git checkout permanent-global-vars

then you can try stuff and then go back to

git checkout master

you can later merge or rebase after thorough testing. so tell me before you merge or rebase. We can decide then what is better.

[gwangjinkim]

Ah by the way - I am running on SBCL 2.4.6

packages versions:

access-20220707-git.tgz             global-vars-20141106-git.tgz
agutil-20210531-git.tgz             http-body-20190813-git.tgz
alexandria-20231021-git.tgz         hunchentoot-v1.3.0.tgz
alexandria-plus-20221106-git.tgz        ieee-floats-20220220-git.tgz
anaphora-20220220-git.tgz           introspect-environment-20220220-git.tgz
archive-20160318-git.tgz            ironclad-v0.59.tgz
arnesi-20170403-git.tgz             iterate-release-b0f9a9c6-git.tgz
array-operations-1.2.1.tgz          jonathan-20200925-git.tgz
array-utils-20231021-git.tgz            jzon-v1.1.2.tgz
arrows-20181018-git.tgz             lack-20231021-git.tgz
asdf-flv-version-2.2.tgz            let-plus-20191130-git.tgz
babel-20230214-git.tgz              lisp-namespace-20221106-git.tgz
bordeaux-threads-v0.9.3.tgz         livesupport-release-quicklisp-71e6e412-git.tgz
cephes.cl-20231021-git.tgz          local-time-20231021-git.tgz
cffi-20231021-git.tgz               log4cl-20230618-git.tgz
chipz-20230618-git.tgz              lparallel-20160825-git.tgz
chronicity-20190202-git.tgz         map-set-20230618-git.tgz
chunga-20231021-git.tgz             md5-20210630-git.tgz
circular-streams-20161204-git.tgz       metering-20200218-git.tgz
cl+ssl-20231021-git.tgz             mgl-pax-20231021-git.tgz
cl-annot-20150608-git.tgz           myway-20221106-git.tgz
cl-ansi-text-20211020-git.tgz           named-readtables-20231021-git.tgz
cl-base64-20201016-git.tgz          ningle-20231021-git.tgz
cl-colors-20180328-git.tgz          numerical-utilities-20231021-git.tgz
cl-colors2-20231021-git.tgz         optima-20150709-git.tgz
cl-cookie-20220707-git.tgz          osicat-20231021-git.tgz
cl-csv-20201016-git.tgz             parse-declarations-20101006-darcs.tgz
cl-emb-20190521-git.tgz             parse-number-v1.7.tgz
cl-environments-20211020-git.tgz        pathname-utils-20231021-git.tgz
cl-fad-20220220-git.tgz             plexippus-xpath-20190521-git.tgz
cl-form-types-20230618-git.tgz          plump-20231021-git.tgz
cl-interpol-20221106-git.tgz            proc-parse-20190813-git.tgz
cl-isaac-20231021-git.tgz           prove-20200218-git.tgz
cl-json-20220707-git.tgz            puri-20201016-git.tgz
cl-locale-20151031-git.tgz          ql-checkout-20190521-git.tgz
cl-marshal-20231021-git.tgz         quri-20230618-git.tgz
cl-parser-combinators-20131111-git.tgz      rfc2388-20180831-git.tgz
cl-ppcre-20230618-git.tgz           rove-20231021-git.tgz
cl-project-20231021-git.tgz         rutils-20221106-git.tgz
cl-slice-20210531-git.tgz           salza2-2.1.tgz
cl-store-20230214-git.tgz           select-20221106-git.tgz
cl-syntax-20150407-git.tgz          serapeum-20231021-git.tgz
cl-unicode-20210228-git.tgz         simple-date-time-20160421-git.tgz
cl-utilities-1.2.4.tgz              slime-v2.28.tgz
cl-yacc-20230214-git.tgz            smart-buffer-20211020-git.tgz
clack-20231021-git.tgz              special-functions-20221106-git.tgz
clavier-20230214-git.tgz            split-sequence-v2.0.1.tgz
claw-stable-git.tgz             static-dispatch-20211209-git.tgz
claw-support-stable-git.tgz         static-vectors-v1.8.9.tgz
claw-utils-stable-git.tgz           statistics-20231021-git.tgz
clhs-0.6.3.tgz                  string-case-20180711-git.tgz
closer-mop-20231021-git.tgz         symbol-munger-20220220-git.tgz
closure-common-20181018-git.tgz         trivia-20230618-git.tgz
collectors-20220220-git.tgz         trivial-backtrace-20230214-git.tgz
conduit-packages-20231021-git.tgz       trivial-cltl2-20211230-git.tgz
csv-20190710-git.tgz                trivial-extensible-sequences-20231021-git.tgz
cxml-20200610-git.tgz               trivial-features-20230618-git.tgz
cxml-stp-20200325-git.tgz           trivial-file-size-20221106-git.tgz
data-frame-20231021-git.tgz         trivial-garbage-20231021-git.tgz
dexador-20231021-git.tgz            trivial-gray-streams-20231021-git.tgz
dissect-20231021-git.tgz            trivial-indent-20231021-git.tgz
distributions-20221106-git.tgz          trivial-macroexpand-all-20171023-git.tgz
djula-20231021-git.tgz              trivial-mimes-20231021-git.tgz
documentation-utils-20231021-git.tgz        trivial-shell-20230214-git.tgz
drakma-v2.0.10.tgz              trivial-types-20120407-git.tgz
duologue-20230214-git.tgz           trivial-utf-8-20231021-git.tgz
eager-future2-20191130-git.tgz          type-i-20230214-git.tgz
fast-http-20231021-git.tgz          usocket-0.8.6.tgz
fast-io-20221106-git.tgz            uuid-20200715-git.tgz
fiveam-20231021-git.tgz             wu-decimal-20130128-git.tgz
flexi-streams-20220220-git.tgz          xmls-release-310ba849-git.tgz
float-features-20231021-git.tgz         xsubseq-20170830-git.tgz
gettext-20171130-git.tgz            zip-20150608-git.tgz

listed by:

ls lisp/quicklisp/dists/quicklisp/archives

[davypough]

Note that (setf *threads* 3) or any other number is not supported in wouldwork. You need to edit ww-settings.lisp, exit sbcl, restart sbcl, and then (ql:quickload :wouldwork) again.