Return to except.fs CVS log

Up to [gforth] / gforth

throw works now for gforth-native

    1: \ catch, throw, etc.
    2: 
    3: \ Copyright (C) 1999,2000,2003 Free Software Foundation, Inc.
    4: 
    5: \ This file is part of Gforth.
    6: 
    7: \ Gforth is free software; you can redistribute it and/or
    8: \ modify it under the terms of the GNU General Public License
    9: \ as published by the Free Software Foundation; either version 2
   10: \ of the License, or (at your option) any later version.
   11: 
   12: \ This program is distributed in the hope that it will be useful,
   13: \ but WITHOUT ANY WARRANTY; without even the implied warranty of
   14: \ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   15: \ GNU General Public License for more details.
   16: 
   17: \ You should have received a copy of the GNU General Public License
   18: \ along with this program; if not, write to the Free Software
   19: \ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
   20: 
   21: \ !! use a separate exception stack?           anton
   22: 
   23: \ user-definable rollback actions
   24: 
   25: Defer 'catch
   26: Defer 'throw
   27: 
   28: ' noop IS 'catch
   29: ' noop IS 'throw
   30: 
   31: \ has? backtrace [IF]
   32: Defer store-backtrace
   33: ' noop IS store-backtrace
   34: \ [THEN]
   35: 
   36: \ Ok, here's the story about how we get to the native code for the
   37: \ recovery code in case of a THROW, and why there is all this funny
   38: \ stuff being compiled by TRY and RECOVER:
   39: 
   40: \ Upon a THROW, we cannot just return through the ordinary return
   41: \ address, but have to use a different one, for code after the
   42: \ RECOVER.  How do we do that, in a way portable between the various
   43: \ threaded and native code engines?  In particular, how does the
   44: \ native code engine learn about the address of the native recovery
   45: \ code?
   46: 
   47: \ On the Forth level, we can compile only references to threaded code.
   48: \ The only thing that translates a threaded code address to a native
   49: \ code address is docol, which is only called with EXECUTE and
   50: \ friends.  So we start the recovery code with a docol, and invoke it
   51: \ with PERFORM; the recovery code then rdrops the superfluously
   52: \ generated return address and continues with the proper recovery
   53: \ code.
   54: 
   55: \ At compile time, since we cannot compile a forward reference (to the
   56: \ recovery code) as a literal (backpatching does not work for
   57: \ native-code literals), we produce a data cell (wrapped in AHEAD
   58: \ ... THEN) that we can backpatch, and compile the address of that as
   59: \ literal.
   60: 
   61: \ Overall, this leads to the following resulting code:
   62: 
   63: \   ahead
   64: \ +><recovery address>-+
   65: \ | then               |
   66: \ +-lit                |
   67: \   (try)              |
   68: \   ...                |
   69: \   (recover)          |
   70: \   ahead              |
   71: \   docol: <-----------+
   72: \   rdrop
   73: \   ...
   74: \   then
   75: \   ...
   76: 
   77: \ !! explain handler on-stack structure
   78: 
   79: : (try) ( ahandler -- )
   80:     r>
   81:     swap >r \ recovery address
   82:     rp@ 'catch >r
   83:     sp@ >r
   84:     fp@ >r
   85:     lp@ >r
   86:     handler @ >r
   87:     rp@ handler !
   88:     backtrace-empty on
   89:     >r ;
   90: 
   91: : try ( compilation  -- orig ; run-time  -- ) \ gforth
   92:     \ !! does not work correctly for gforth-native
   93:     POSTPONE ahead here >r >mark 1 cs-roll POSTPONE then
   94:     r> POSTPONE literal POSTPONE (try) ; immediate compile-only
   95: 
   96: : (recover) ( -- )
   97:     \ normal end of try block: restore handler, forget rest
   98:     r>
   99:     r> handler !
  100:     rdrop \ lp
  101:     rdrop \ fp
  102:     rdrop \ sp
  103:     r> rp!
  104:     rdrop \ recovery address
  105:     >r ;
  106: 
  107: : recover ( compilation  orig1 -- orig2 ; run-time  -- ) \ gforth
  108:     \ !! check using a special tag
  109:     POSTPONE (recover)
  110:     POSTPONE else
  111:     docol: here 0 , 0 , code-address! \ start a colon def 
  112:     postpone rdrop                    \ drop the return address
  113: ; immediate compile-only
  114: 
  115: : endtry ( compilation  orig -- ; run-time  -- ) \ gforth
  116:     POSTPONE then ; immediate compile-only
  117: 
  118: :noname ( x1 .. xn xt -- y1 .. ym 0 / z1 .. zn error ) \ exception
  119:     try
  120: 	execute 0
  121:     recover
  122:         nip
  123:     endtry ;
  124: is catch
  125: 
  126: :noname ( y1 .. ym error/0 -- y1 .. ym / z1 .. zn error ) \ exception
  127:     ?DUP IF
  128: 	[ here forthstart 9 cells + ! ]
  129: 	store-backtrace
  130: 	handler @ ?dup-0=-IF
  131: 	    >stderr cr ." uncaught exception: " .error cr
  132: 	    2 (bye)
  133: \	    quit
  134: 	THEN
  135: 	rp!
  136: 	r> handler !
  137: 	r> lp!
  138: 	r> fp!
  139: 	r> swap >r sp! drop r>
  140: 	rdrop 'throw r> perform
  141:     THEN ;
  142: is throw
  143: