Diff for /gforth/glocals.fs between versions 1.27 and 1.59

version 1.27, 1996/09/24 19:15:02 version 1.59, 2007/12/31 17:34:58
Line 1 Line 1
 \ A powerful locals implementation  \ A powerful locals implementation
   
 \ Copyright (C) 1995 Free Software Foundation, Inc.  \ Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2007 Free Software Foundation, Inc.
   
 \ This file is part of Gforth.  \ This file is part of Gforth.
   
Line 16 Line 16
   
 \ You should have received a copy of the GNU General Public License  \ You should have received a copy of the GNU General Public License
 \ along with this program; if not, write to the Free Software  \ along with this program; if not, write to the Free Software
 \ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  \ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
   
   
 \ More documentation can be found in the manual and in  \ More documentation can be found in the manual and in
Line 85 Line 85
 \ Currently locals may only be  \ Currently locals may only be
 \ defined at the outer level and TO is not supported.  \ defined at the outer level and TO is not supported.
   
 require search-order.fs  require search.fs
 require float.fs  require float.fs
   require extend.fs \ for case
   
 : compile-@local ( n -- ) \ gforth compile-fetch-local  : compile-@local ( n -- ) \ gforth compile-fetch-local
  case   case
Line 129  require float.fs Line 130  require float.fs
 slowvoc @  slowvoc @
 slowvoc on \ we want a linked list for the vocabulary locals  slowvoc on \ we want a linked list for the vocabulary locals
 vocabulary locals \ this contains the local variables  vocabulary locals \ this contains the local variables
 ' locals >body ' locals-list >body !  ' locals >body wordlist-id ' locals-list >body !
 slowvoc !  slowvoc !
   
 create locals-buffer 1000 allot \ !! limited and unsafe  create locals-buffer 1000 allot \ !! limited and unsafe
Line 183  variable locals-dp \ so here's the speci Line 184  variable locals-dp \ so here's the speci
  = ;   = ;
   
 : list-size ( list -- u ) \ gforth-internal  : list-size ( list -- u ) \ gforth-internal
 \ size of the locals frame represented by list      \ size of the locals frame represented by list
  0 ( list n )      0 ( list n )
  begin      begin
    over 0<>          over 0<>
  while      while
    over          over
    ((name>)) >body @ max          ((name>)) >body @ max
    swap @ swap ( get next )          swap @ swap ( get next )
  repeat      repeat
  faligned nip ;      faligned nip ;
   
 : set-locals-size-list ( list -- )  : set-locals-size-list ( list -- )
  dup locals-list !      dup locals-list !
  list-size locals-size ! ;      list-size locals-size ! ;
   
 : check-begin ( list -- )  : check-begin ( list -- )
 \ warn if list is not a sublist of locals-list  \ warn if list is not a sublist of locals-list
Line 292  locals-types definitions Line 293  locals-types definitions
         postpone laddr# @ lp-offset, ;          postpone laddr# @ lp-offset, ;
   
 \ you may want to make comments in a locals definitions group:  \ you may want to make comments in a locals definitions group:
 ' \ alias \ immediate  ' \ alias \ ( compilation 'ccc<newline>' -- ; run-time -- ) \ core-ext,block-ext backslash
 ' ( alias ( immediate  \G Comment till the end of the line if @code{BLK} contains 0 (i.e.,
   \G while not loading a block), parse and discard the remainder of the
   \G parse area. Otherwise, parse and discard all subsequent characters
   \G in the parse area corresponding to the current line.
   immediate
   
   ' ( alias ( ( compilation 'ccc<close-paren>' -- ; run-time -- ) \ core,file     paren
   \G Comment, usually till the next @code{)}: parse and discard all
   \G subsequent characters in the parse area until ")" is
   \G encountered. During interactive input, an end-of-line also acts as
   \G a comment terminator. For file input, it does not; if the
   \G end-of-file is encountered whilst parsing for the ")" delimiter,
   \G Gforth will generate a warning.
   immediate
   
 forth definitions  forth definitions
   also locals-types
       
   \ these "locals" are used for comparison in TO
   
   c: some-clocal 2drop
   d: some-dlocal 2drop
   f: some-flocal 2drop
   w: some-wlocal 2drop
       
 \ the following gymnastics are for declaring locals without type specifier.  \ the following gymnastics are for declaring locals without type specifier.
 \ we exploit a feature of our dictionary: every wordlist  \ we exploit a feature of our dictionary: every wordlist
 \ has it's own methods for finding words etc.  \ has it's own methods for finding words etc.
 \ So we create a vocabulary new-locals, that creates a 'w:' local named x  \ So we create a vocabulary new-locals, that creates a 'w:' local named x
 \ when it is asked if it contains x.  \ when it is asked if it contains x.
   
 also locals-types  
   
 : new-locals-find ( caddr u w -- nfa )  : new-locals-find ( caddr u w -- nfa )
 \ this is the find method of the new-locals vocabulary  \ this is the find method of the new-locals vocabulary
 \ make a new local with name caddr u; w is ignored  \ make a new local with name caddr u; w is ignored
 \ the returned nfa denotes a word that produces what W: produces  \ the returned nfa denotes a word that produces what W: produces
 \ !! do the whole thing without nextname  \ !! do the whole thing without nextname
     drop nextname      drop nextname
     ['] W: >name ;      ['] W: >head-noprim ;
   
 previous  previous
   
Line 319  previous Line 339  previous
   true abort" this should not happen: new-locals-reveal" ;    true abort" this should not happen: new-locals-reveal" ;
   
 create new-locals-map ( -- wordlist-map )  create new-locals-map ( -- wordlist-map )
 ' new-locals-find A, ' new-locals-reveal A,  ' new-locals-find A,
   ' new-locals-reveal A,
 slowvoc @  ' drop A, \ rehash method
 slowvoc on  ' drop A,
 vocabulary new-locals  
 slowvoc !  new-locals-map mappedwordlist Constant new-locals-wl
 new-locals-map ' new-locals >body cell+ A! \ !! use special access words  
   \ slowvoc @
   \ slowvoc on
   \ vocabulary new-locals
   \ slowvoc !
   \ new-locals-map ' new-locals >body wordlist-map A! \ !! use special access words
   
 variable old-dpp  variable old-dpp
   
 \ and now, finally, the user interface words  \ and now, finally, the user interface words
 : { ( -- addr wid 0 ) \ gforth open-brace  : { ( -- latestxt wid 0 ) \ gforth open-brace
     dp old-dpp !      dp old-dpp !
     locals-dp dpp !      locals-dp dpp !
     also new-locals      latestxt get-current
     also get-current locals definitions  locals-types      get-order new-locals-wl swap 1+ set-order
       also locals definitions locals-types
     0 TO locals-wordlist      0 TO locals-wordlist
     0 postpone [ ; immediate      0 postpone [ ; immediate
   
 locals-types definitions  locals-types definitions
   
 : } ( addr wid 0 a-addr1 xt1 ... -- ) \ gforth close-brace  : } ( latestxt wid 0 a-addr1 xt1 ... -- ) \ gforth close-brace
     \ ends locals definitions      \ ends locals definitions
     ] old-dpp @ dpp !      ] old-dpp @ dpp !
     begin      begin
Line 350  locals-types definitions Line 376  locals-types definitions
     repeat      repeat
     drop      drop
     locals-size @ alignlp-f locals-size ! \ the strictest alignment      locals-size @ alignlp-f locals-size ! \ the strictest alignment
     set-current  
     previous previous      previous previous
     locals-list TO locals-wordlist ;      set-current lastcfa !
       locals-list 0 wordlist-id - TO locals-wordlist ;
   
 : -- ( addr wid 0 ... -- ) \ gforth dash-dash  : -- ( addr wid 0 ... -- ) \ gforth dash-dash
     }      }
Line 448  forth definitions Line 474  forth definitions
   
 \ If this assumption is too optimistic, the compiler will warn the user.  \ If this assumption is too optimistic, the compiler will warn the user.
   
 \ Implementation: migrated to kernel.fs  \ Implementation:
   
 \ THEN (another control flow from before joins the current one):  
 \ The new locals-list is the intersection of the current locals-list and  
 \ the orig-local-list. The new locals-size is the (alignment-adjusted)  
 \ size of the new locals-list. The following code is generated:  
 \ lp+!# (current-locals-size - orig-locals-size)  
 \ <then>:  
 \ lp+!# (orig-locals-size - new-locals-size)  
   
 \ Of course "lp+!# 0" is not generated. Still this is admittedly a bit  
 \ inefficient, e.g. if there is a locals declaration between IF and  
 \ ELSE. However, if ELSE generates an appropriate "lp+!#" before the  
 \ branch, there will be none after the target <then>.  
   
 \ explicit scoping  \ explicit scoping
   
 : scope ( compilation  -- scope ; run-time  -- ) \ gforth  : scope ( compilation  -- scope ; run-time  -- ) \ gforth
  cs-push-part scopestart ; immediate      cs-push-part scopestart ; immediate
   
   : adjust-locals-list ( wid -- )
       locals-list @ common-list
       dup list-size adjust-locals-size
       locals-list ! ;
   
 : endscope ( compilation scope -- ; run-time  -- ) \ gforth  : endscope ( compilation scope -- ; run-time  -- ) \ gforth
  scope?      scope?
  drop      drop  adjust-locals-list ; immediate
  locals-list @ common-list  
  dup list-size adjust-locals-size  
  locals-list ! ; immediate  
   
 \ adapt the hooks  \ adapt the hooks
   
 : locals-:-hook ( sys -- sys addr xt n )  : locals-:-hook ( sys -- sys addr xt n )
     \ addr is the nfa of the defined word, xt its xt      \ addr is the nfa of the defined word, xt its xt
     DEFERS :-hook      DEFERS :-hook
     last @ lastcfa @      latest latestxt
     clear-leave-stack      clear-leave-stack
     0 locals-size !      0 locals-size !
     locals-buffer locals-dp !      locals-buffer locals-dp !
Line 495  forth definitions Line 510  forth definitions
     lastcfa ! last !      lastcfa ! last !
     DEFERS ;-hook ;      DEFERS ;-hook ;
   
 : (then-like) ( orig -- addr )  \ THEN (another control flow from before joins the current one):
     swap -rot dead-orig =  \ The new locals-list is the intersection of the current locals-list and
   \ the orig-local-list. The new locals-size is the (alignment-adjusted)
   \ size of the new locals-list. The following code is generated:
   \ lp+!# (current-locals-size - orig-locals-size)
   \ <then>:
   \ lp+!# (orig-locals-size - new-locals-size)
   
   \ Of course "lp+!# 0" is not generated. Still this is admittedly a bit
   \ inefficient, e.g. if there is a locals declaration between IF and
   \ ELSE. However, if ELSE generates an appropriate "lp+!#" before the
   \ branch, there will be none after the target <then>.
   
   : (then-like) ( orig -- )
       dead-orig =
     if      if
         drop          >resolve drop
     else      else
         dead-code @          dead-code @
         if          if
             set-locals-size-list dead-code off              >resolve set-locals-size-list dead-code off
         else \ both live          else \ both live
             dup list-size adjust-locals-size              over list-size adjust-locals-size
             locals-list @ common-list dup list-size adjust-locals-size              >resolve
             locals-list !              adjust-locals-list
         then          then
     then ;      then ;
   
Line 570  forth definitions Line 598  forth definitions
 \ things above are not control flow joins. Everything should be taken  \ things above are not control flow joins. Everything should be taken
 \ over from the live flow. No lp+!# is generated.  \ over from the live flow. No lp+!# is generated.
   
 \ !! The lp gymnastics for UNTIL are also a real problem: locals cannot be  
 \ used in signal handlers (or anything else that may be called while  
 \ locals live beyond the lp) without changing the locals stack.  
   
 \ About warning against uses of dead locals. There are several options:  \ About warning against uses of dead locals. There are several options:
   
 \ 1) Do not complain (After all, this is Forth;-)  \ 1) Do not complain (After all, this is Forth;-)
Line 614  forth definitions Line 638  forth definitions
         2drop          2drop
     endif ;      endif ;
   
 : >definer ( xt -- definer )  : >definer ( xt -- definer ) \ gforth
     \ this gives a unique identifier for the way the xt was defined      \G @var{Definer} is a unique identifier for the way the @var{xt}
     \ words defined with different does>-codes have different definers      \G was defined.  Words defined with different @code{does>}-codes
     \ the definer can be used for comparison and in definer!      \G have different definers.  The definer can be used for
     dup >code-address [ ' spaces >code-address ] Literal =      \G comparison and in @code{definer!}.
     \ !! this definition will not work on some implementations for `bits'      dup >does-code
     if  \ if >code-address delivers the same value for all does>-def'd words      ?dup-if
         >does-code 1 or \ bit 0 marks special treatment for does codes          nip 1 or
     else      else
         >code-address          >code-address
     then ;      then ;
   
 : definer! ( definer xt -- )  : definer! ( definer xt -- ) \ gforth
     \ gives the word represented by xt the behaviour associated with definer      \G The word represented by @var{xt} changes its behaviour to the
       \G behaviour associated with @var{definer}.
     over 1 and if      over 1 and if
         swap [ 1 invert ] literal and does-code!          swap [ 1 invert ] literal and does-code!
     else      else
Line 635  forth definitions Line 660  forth definitions
     then ;      then ;
   
 :noname  :noname
     ' dup >definer [ ' locals-wordlist >definer ] literal =      ' dup >definer [ ' locals-wordlist ] literal >definer =
     if      if
         >body !          >body !
     else      else
         -&32 throw          -&32 throw
     endif ;      endif ;
 :noname  :noname
     0 0 0. 0.0e0 { c: clocal w: wlocal d: dlocal f: flocal }      comp' drop dup >definer
     ' dup >definer  
     case      case
         [ ' locals-wordlist >definer ] literal \ value          [ ' locals-wordlist ] literal >definer \ value
         OF >body POSTPONE Aliteral POSTPONE ! ENDOF          OF >body POSTPONE Aliteral POSTPONE ! ENDOF
         [ comp' clocal drop >definer ] literal          \ !! dependent on c: etc. being does>-defining words
           \ this works, because >definer uses >does-code in this case,
           \ which produces a relocatable address
           [ comp' some-clocal drop ] literal >definer
         OF POSTPONE laddr# >body @ lp-offset, POSTPONE c! ENDOF          OF POSTPONE laddr# >body @ lp-offset, POSTPONE c! ENDOF
         [ comp' wlocal drop >definer ] literal          [ comp' some-wlocal drop ] literal >definer
         OF POSTPONE laddr# >body @ lp-offset, POSTPONE ! ENDOF          OF POSTPONE laddr# >body @ lp-offset, POSTPONE ! ENDOF
         [ comp' dlocal drop >definer ] literal          [ comp' some-dlocal drop ] literal >definer
         OF POSTPONE laddr# >body @ lp-offset, POSTPONE 2! ENDOF          OF POSTPONE laddr# >body @ lp-offset, POSTPONE 2! ENDOF
         [ comp' flocal drop >definer ] literal          [ comp' some-flocal drop ] literal >definer
         OF POSTPONE laddr# >body @ lp-offset, POSTPONE f! ENDOF          OF POSTPONE laddr# >body @ lp-offset, POSTPONE f! ENDOF
         -&32 throw          -&32 throw
     endcase ;      endcase ;
 interpret/compile: TO ( c|w|d|r "name" -- ) \ core-ext,local  interpret/compile: TO ( c|w|d|r "name" -- ) \ core-ext,local
   
 : locals|  : locals| ( ... "name ..." -- ) \ local-ext locals-bar
     \ don't use 'locals|'! use '{'! A portable and free '{'      \ don't use 'locals|'! use '{'! A portable and free '{'
     \ implementation is compat/anslocals.fs      \ implementation is compat/anslocals.fs
     BEGIN      BEGIN
         name 2dup s" |" compare 0<>          name 2dup s" |" str= 0=
     WHILE      WHILE
         (local)          (local)
     REPEAT      REPEAT

Removed from v.1.27  
changed lines
  Added in v.1.59


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>