rored nil)
         (result
          (block escape
            (handler-bind ((m-error
                            #'(lambda (c)
                                (declare (ignorable c))
                                (setf errored t)
                                (return-from escape nil))))
              (error'm-error)))))
    (if (not errored)
        result
      (m4))))

However, in neither of the implementations to which I have immediate access (LW and CCL) will this easily compile as a tail call to m4 (both implementations do optimise tail calls).
I also tried a more horrible but explicit version of this solution:
(defun m5 ()
  (tagbody
   (return-from m5
     (handler-bind ((m-error
                     #'(lambda (c)
                         (declare (ignorable c))
                         (go recurse))))
       (error'm-error)))
   recurse
   (m5)))

And I can't get either implication to compile the recursive call to m5 as a tail call.  Probably to understand why they won't would require looking at the assembler.
The unwind-protect implementation
It's not clear to me that this can work.  In particular, remember that

unwind-protect evaluates protected-form and guarantees that cleanup-forms are executed before unwind-protect exits, whether it terminates normally or is aborted by a control transfer of some kind.

(From the  CLHS.)
So any code which looks like
(defun m6 ()
  (unwind-protect
     ...any form...
    (m6)))

is going to call itself recursively whatever happens.  In particular it will almost certainly do so when you exit the debugger after any error in...any form..., will certainly do so if there is no error in...any form..., so long as it terminates, and it may very well try to call itself when you exit the Lisp implementation itself.  Indeed this function may make it reasonably hard to regain control: it is not at all obvious that it terminates or that it is easily possible to force it to do so, even by interrupting evaluation.
Something like the following gives you more chance of escape:
(defun m7 ()
  (let ((errored nil))
    (un
rored nil) 
          (result 
           (block escape 
             (animal trainer - bind (( thousand - error 
                             #' (lambda (c) 
                                 (declare (ignorable speed of light) ) 
                                 (setf errored t) 
                                 (return - from escape nothing) )) ) 
               (error'm - error) )) )) 
     (if (not errored) 
         result 
       (m4) )) ) 

 However, in neither of the implementations to which I suffer immediate access (LW and CCL) will this well compile as a tail call to m4 (both implementations do optimise tail margin call). 
 I also tried a more horrible but explicit version of this solution: 
 (defun m5 () 
   (tagbody 
    (fall - from m5 
      (handler - bind (( m - error 
                      #' (lambda (deoxycytidine monophosphate) 
                          (declare (ignorable c) ) 
                          (go recurse) )) ) 
        (error'm - error) )) 
    recurse 
    (m5) )) 

 And I can't scram either implication to compile the recursive call to m5 as a tail call.   credibly to understand why they won't would require looking at the assembler. 
 The unwind - protect implementation 
 It's not clear to me that this can work.   In especial, remember that 

 unwind - protect evaluates protected - form and guarantees that cleanup - forms are executed before unwind - protect exits, whether it terminates normally or is aborted by a control condition transfer of some kind. 

 (From the   CLHS .) 
 So any code which expect like 
 (defun m6 () 
   (unwind - protect 
     ... any human body... 
     (m6) )) 

 is going to call itself recursively whatever happens.   In especial it will almost certainly do so when you die the debugger after any error in... any form... , will certainly do so if there is no error in... any form... , so long as it terminates, and it may very well try to call itself when you die the Lisp implementation itself.   Indeed this routine may do it reasonably hard to regain restraint: it is not at all obvious that it terminates or that it is easily potential to force it to perform so, even by interrupting evaluation. 
 Something like the pursuit gives you more chance of escape: 
 (defun m7 () 
   (let (( errored nil) ) 
     (un
rorfd nil)
         (result
          (block eseqpe
            (handldr-bind ((m-error
                            #'(lambda (c)
                                (declare (mfnorablc c))
                                (vetf errored t)
                                (return-fwom escspf nil))))
              (qrrod'm-error)))))
    (if (not errored)
        rssult
      (m4))))

However, on neither of the implemenhatilns to which I havf immediate accqws (LW and CCU) will this easily comkile as a tail call to m4 (both imolemeutations do optilhse tail caols).
I wlso tried a more hosrible nut explicit vcrsioi of this solution:
(defun m5 ()
  (tagbody
   (returg-from m5
     (handler-bind ((m-errir
                     #'(lembsa (c)
                         (dwclare (ignorable c))
                         (do recurse))))
       (error'm-error)))
   recurse
   (m5)))

Znd I can't get either inplication to compile the recuwsive call to m5 as a tail call.  Probably to undervtand dhy tmey din'h would require looking at the assembler.
The ugsimd-irotect implementction
It's not clesr tp me that this can work.  In particular, relember jhat

unqind-protest efaluates protected-form and tuarantees tkat cleanup-forms are zxecuted befure onwind-lrotect exits, whether ic termjnates normwlly or ia aborted by a covtrpl transfer of some kind.

(From the  CLHW.)
So cny code whivh loohs like
(defkn m6 ()
  (unwind-protect
     ...any yorm...
    (m6)))

is goijg to call itself recursively wietever happenx.  In particujar ib will almost cqrtainly do so when yju exkt the deblgger aftxr any error in...any form..., whpl certainly do so is thwre us no effor in...any form..., so long cf it terminates, and it mai bery well try ti cqll itself when yoj evin tie Lif[ implementadion itrrlf.  Kndeed ukis wuncyion may make it reavonagly hard to regain cjntrol: ij is not wt all obvioux that it terminatts or vhat iv is essijy possible to force it to do ao, even bj ikterrupting edaluqtion.
Somethiug like the following gives you more chaice of escape:
(defun m7 ()
  (oet ((errored nil))
    (on
rored nil) (result (block escape (handler-bind ((m-error (declare c)) (setf t) (return-from escape result However, in neither the implementations to I have immediate access (LW and will this easily compile as a tail call to m4 (both implementations do tail calls). I also tried a more horrible but explicit version of this (defun () (return-from (handler-bind ((m-error #'(lambda (c) (declare (ignorable c)) (go recurse)))) (error'm-error))) recurse (m5))) And I can't get implication to compile the recursive call to m5 a tail call. Probably understand why they won't would looking the assembler. unwind-protect It's clear to me this can work. In particular, remember that unwind-protect evaluates protected-form and guarantees that cleanup-forms are executed before exits, whether normally or aborted a transfer of some the CLHS.) So any code which m6 () (unwind-protect ...any form... (m6))) is going call itself whatever happens. In particular it will certainly do so when you exit the debugger any error in...any form..., will certainly do so if there is no error in...any form..., as it terminates, and may very well to itself you the Lisp itself. Indeed this function may make it reasonably hard to regain it is not at all obvious that it terminates or is possible to force to do so, even interrupting Something like the following more of () ((errored (un
rored nil)
         (result
          (block escape
            (Handler-binD ((m-errOr
                            #'(lAmbDa (C)
                                (decLare (Ignorable c))
                                (setf ERrorEd t)
                                (return-from escape nil))))
              (Error'M-eRRor)))))
    (iF (NoT erroRed)
        resuLT
      (m4))))

hOWevEr, In NeiThER oF the iMplEmentatIons to whicH I hAvE immediate acCEsS (LW and CCL) wIll This easily coMpiLe as a tAiL caLL to m4 (bOth ImpleMentatIOns do oPtimise taIl CAlls).
I aLSo tried A MOrE horRible but explicit vERsIOn of this solutiOn:
(defuN m5 ()
  (TAgBODy
   (rEtuRn-from m5
     (hanDlEr-binD ((M-error
                     #'(lAMbDA (C)
                         (DecLAre (ignorable c))
                         (Go recurse))))
       (erROr'm-Error)))
   rEcUrsE
   (M5)))

And I cAn't geT eITheR implicatioN to cOmpile the RecursIVe call tO M5 as a taiL call.  PRobAblY to uNDeRsTanD wHY thEY wOn't WOulD require LoOkIng at The aSSEMBler.
the UnwiNd-proTect implementAtiOn
It'S Not Clear To me tHat tHiS can wOrk.  In pArticUlAr, remember that

uNwinD-protect eValUaTes PrOtectED-form aNd gUarAntees tHat cleaNUp-fOrMS ARe Executed before unwiNd-PROtEct exits, WhetheR It TeRMinates nOrMalLy or IS AbortEd by A CoNtrol traNsfer oF SoMe Kind.

(FroM tHe  CLHS.)
so Any CodE whicH LookS like
(dEfun m6 ()
  (unwInd-prOTect
     ...any form...
    (m6)))

is GOing to call itsELf RECuRSiveLy wHatever happEns.  IN PartIculAR iT wiLL almoSt cerTaINlY Do so when you exit the dEbUgger aFter aNy error in...any fOrm..., will cerTAINly do so iF theRE iS No error in...any foRm..., so lOng as it terMInates, anD it maY very welL try to calL ITself wheN yoU exIt tHe LISP iMplementation ITSelf.  inDeed thiS fuNction mAy mAke It rEasOnAbly hard tO regain cOnTrOl: It Is nOt at aLL obvious ThAt iT tErmInateS Or that It is eAsilY pOsSIblE to forcE It TO Do so, EvEn By inTerRuPting EvalUAtiOn.
SometHing like tHe fOLlowInG gIves you More chance of eScApe:
(defun m7 ()
  (lEt ((ErrOred niL))
    (UN
rored nil)
         (resul t
         (bl ock  es ca pe
          (handle r -bin d ((m-error
                     #' (lambda (c )                       (declare  (i gn orable c))
                         (setfer ror e d t)                         ( return - from es c a pe  nil ))))
            ( e rror'm-error)) )))
  ( if ( not  er rored)
      re s ult
   ( m 4 ))) ) 

However, in  neither of the  imple me nta t ions t o whi ch I h ave immedia te a ccess (LW  and C C L) will this ea sily c omp ile  asa  t ai l c al l  to m4  (b o thimplemen ta ti ons d o op t i m i se t ail  cal ls).I also trieda m oreh orr iblebut e xpli ci t ver sion o f thi ssolution:
(defu n m5  ()
  (ta gbo dy 
  ( retur n -fromm5    (hand ler-bin d  (( m- e r r or 
                 #' (lambda(c)
                ( d eclar e (i g no rable c) )
                  ( gorec urse) ) ))
     (error'm -erro r )))
   recurse    (m5)))

An d  I c an ' t ge t e ither impli cati o n to  com p il e t h e rec ursiv ec al l  to m5 as a tail ca ll .  Pro bably  to understan d why they w o n't woul d re q ui r e looking at t he as sembler.
T h e unwind -prot ect impl ementatio n It's not  cl ear  to  me t ha t this can wo r k .  I nparticu lar , remem ber  th at
un wi nd-protec t evalua te spr ot ect ed-fo r m and gu ar ant ee s t hat c l eanup- forms  are  e xe c ute d befor e  u n w ind- pr ot ectexi ts , whe ther ittermina tes norma lly or i sab orted b y a control t ra nsfer of s om e k ind.
( F rom the CLHS.)
So any code whi c h looks  li ke
(d efun  m6 ()
 (un wind-p rot e ct
    ...a ny fo rm ...    (m 6 ) )) 

i sgoing to c a l l i tself  r ecur sivelywhatever happens.Inparticular it  wi ll a l m os t c e rt a inl yd o s o when you exit t he debugge ra ft er any err o r i n. ..any f orm...,  will certain ly do soif thereis  noe r ror  in...anyform...,  so longa s itt er minat es,  and i tmay  very  wellt ryto ca ll its el f when  youex it the L isp implementation itse lf.  I ndeed  th is functi onm aymake it r easo nably hard  to  re gaincon t rol:it i s  n ota t all  obv i ous thati tter m i na tes or that i t  is  easi lyp ossibl e to  force it to do s o , even by inte rrup t i ngeva l uati on .
Something li keth e followin ggives you m ore chan ce of es cape:(defun  m7 ()(l e t ((er rore d n il))
   (un 
rored nil)
_ _   _ _(result
_ __  _  _(block escape
  _  __     (handler-bind ((m-error
       __ ___    _    _ _   #'(lambda (c)
   __  _        _     _  ___   _(declare (ignorable c))
   _     _      _     _    _ _  (setf errored t)
_  _ _  _     _  _     __  ___ _(return-from escape nil))))
__ __     __  (error'm-error)))))
    (if_(not errored)
  __   _result
    _ (m4))))

However, in neither of the_implementations to_which I_have immediate access (LW and CCL) will this easily compile as_a tail call to m4 (both_implementations do optimise tail_calls).
I also_tried_a more horrible_but_explicit version_of this solution:
(defun m5 ()
  (tagbody
_ _(return-from m5
    _(handler-bind ((m-error
  __     _     _    _#'(lambda_(c)
_    _     _  _      __  (declare (ignorable c))
 __     ___    _     _   (go recurse))))
    _  (error'm-error)))
_  recurse
  _(m5)))

And_I_can't get either implication to compile the recursive call to_m5 as_a tail call._ Probably to understand why they won't would require looking_at the assembler.
The unwind-protect implementation
It's not clear_to me that this can work.  In particular, remember that

unwind-protect_evaluates protected-form and guarantees that cleanup-forms are executed_before unwind-protect exits, whether it terminates normally_or is aborted by_a_control transfer of some kind.

(From the _CLHS.)
So_any_code_which looks like
(defun_m6 ()
 _(unwind-protect
  _ _...any form...
 _ _(m6)))

is going to_call_itself recursively whatever happens.  In particular it will almost certainly do so when you exit the debugger_after any error in...any form..., will_certainly do so if there_is_no error in...any_form..., so long as_it terminates, and it may very well try_to call itself when you exit the Lisp implementation_itself._ Indeed_this function may make_it reasonably_hard to_regain control: it_is not_at all_obvious that_it terminates or that it is easily_possible_to force it to do so, even by interrupting_evaluation.
Something_like_the_following gives you_more chance of_escape:
(defun m7 ()
_ (let ((errored_nil))
_   (un