Diff for /gforth/glocals.fs between versions 1.6 and 1.69

version 1.6, 1994/08/31 19:42:47 version 1.69, 2012/06/27 20:49:34
Line 1 Line 1
   \ A powerful locals implementation
   
   \ Copyright (C) 1995,1996,1997,1998,2000,2003,2004,2005,2007,2011 Free Software Foundation, Inc.
   
   \ This file is part of Gforth.
   
   \ Gforth is free software; you can redistribute it and/or
   \ modify it under the terms of the GNU General Public License
   \ as published by the Free Software Foundation, either version 3
   \ of the License, or (at your option) any later version.
   
   \ This program is distributed in the hope that it will be useful,
   \ but WITHOUT ANY WARRANTY; without even the implied warranty of
   \ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   \ GNU General Public License for more details.
   
   \ You should have received a copy of the GNU General Public License
   \ along with this program. If not, see http://www.gnu.org/licenses/.
   
   
   \ More documentation can be found in the manual and in
   \ http://www.complang.tuwien.ac.at/papers/ertl94l.ps.gz
   
 \ Local variables are quite important for writing readable programs, but  \ Local variables are quite important for writing readable programs, but
 \ IMO (anton) they are the worst part of the standard. There they are very  \ IMO (anton) they are the worst part of the standard. There they are very
 \ restricted and have an ugly interface.  \ restricted and have an ugly interface.
Line 56 Line 79
 \ aligned correctly, but our locals stack must be float-aligned between  \ aligned correctly, but our locals stack must be float-aligned between
 \ words.  \ words.
   
 \ Other things about the internals are pretty unclear now.  require search.fs
   require float.fs
 \ Currently locals may only be  require extend.fs \ for case
 \ defined at the outer level and TO is not supported.  
   
 include float.fs  
 include search-order.fs  
   
 : compile-@local ( n -- )  : compile-@local ( n -- ) \ gforth compile-fetch-local
  case   case
     0 of postpone @local0 endof      0       of postpone @local0 endof
     4 of postpone @local4 endof      1 cells of postpone @local1 endof
     8 of postpone @local8 endof      2 cells of postpone @local2 endof
    12 of postpone @local12 endof      3 cells of postpone @local3 endof
    ( otherwise ) dup postpone @local# ,     ( otherwise ) dup postpone @local# ,
  endcase ;   endcase ;
   
 : compile-f@local ( n -- )  : compile-f@local ( n -- ) \ gforth compile-f-fetch-local
  case   case
     0 of postpone f@local0 endof      0        of postpone f@local0 endof
     8 of postpone f@local8 endof      1 floats of postpone f@local1 endof
    ( otherwise ) dup postpone f@local# ,     ( otherwise ) dup postpone f@local# ,
  endcase ;   endcase ;
   
   \ locals stuff needed for control structures
   
   : compile-lp+! ( n -- ) \ gforth        compile-l-p-plus-store
       dup negate locals-size +!
       0 over = if
       else -1 cells  over = if postpone lp-
       else  1 floats over = if postpone lp+
       else  2 floats over = if postpone lp+2
       else postpone lp+!# dup ,
       then then then then drop ;
   
   : adjust-locals-size ( n -- ) \ gforth
       \ sets locals-size to n and generates an appropriate lp+!
       locals-size @ swap - compile-lp+! ;
   
 \ the locals stack grows downwards (see primitives)  \ the locals stack grows downwards (see primitives)
 \ of the local variables of a group (in braces) the leftmost is on top,  \ of the local variables of a group (in braces) the leftmost is on top,
 \ i.e. by going onto the locals stack the order is reversed.  \ i.e. by going onto the locals stack the order is reversed.
Line 90  include search-order.fs Line 124  include search-order.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  variable locals-mem-list \ linked list of all locals name memory in
     \ here the names of the local variables are stored  0 locals-mem-list !      \ the current (outer-level) definition
     \ we would have problems storing them at the normal dp  
   
 variable locals-dp \ so here's the special dp for locals.  : free-list ( addr -- )
       \ free all members of a linked list (link field is first)
       begin
           dup while
               dup @ swap free throw
       repeat
       drop ;
   
   : prepend-list ( addr1 addr2 -- )
       \ addr1 is the address of a list element, addr2 is the address of
       \ the cell containing the address of the first list element
       2dup @ swap ! \ store link to next element
       ! ; \ store pointer to new first element
   
 : alignlp-w ( n1 -- n2 )  : alignlp-w ( n1 -- n2 )
     \ cell-align size and generate the corresponding code for aligning lp      \ cell-align size and generate the corresponding code for aligning lp
Line 118  variable locals-dp \ so here's the speci Line 163  variable locals-dp \ so here's the speci
     swap !      swap !
     postpone >l ;      postpone >l ;
   
   \ locals list operations
   
   : list-length ( list -- u )
       0 swap begin ( u1 list1 )
           dup while
               @ swap 1+ swap
       repeat
       drop ;
   
   : /list ( list1 u -- list2 )
       \ list2 is list1 with the first u elements removed
       0 ?do
           @
       loop ;
   
   : common-list ( list1 list2 -- list3 )
       \ list3 is the largest common tail of both lists.
       over list-length over list-length - dup 0< if
           negate >r swap r>
       then ( long short u )
       rot swap /list begin ( list3 list4 )
           2dup u<> while
               @ swap @
       repeat
       drop ;
   
   : sub-list? ( list1 list2 -- f )
       \ true iff list1 is a sublist of list2
       over list-length over list-length swap - 0 max /list = ;
   
   \ : ocommon-list ( list1 list2 -- list3 ) \ gforth-internal
   \ \ list1 and list2 are lists, where the heads are at higher addresses than
   \ \ the tail. list3 is the largest sublist of both lists.
   \  begin
   \    2dup u<>
   \  while
   \    2dup u>
   \    if
   \      swap
   \    then
   \    @
   \  repeat
   \  drop ;
   
   \ : osub-list? ( list1 list2 -- f ) \ gforth-internal
   \ \ true iff list1 is a sublist of list2
   \  begin
   \    2dup u<
   \  while
   \    @
   \  repeat
   \  = ;
   
   \ defer common-list
   \ defer sub-list?
   
   \ ' ocommon-list is common-list
   \ ' osub-list?   is sub-list?
   
   : list-size ( list -- u ) \ gforth-internal
       \ size of the locals frame represented by list
       0 ( list n )
       begin
           over 0<>
       while
           over
           ((name>)) >body @ max
           swap @ swap ( get next )
       repeat
       faligned nip ;
   
   : set-locals-size-list ( list -- )
       dup locals-list !
       list-size locals-size ! ;
   
   : check-begin ( list -- )
   \ warn if list is not a sublist of locals-list
    locals-list @ sub-list? 0= if
      \ !! print current position
        >stderr ." compiler was overly optimistic about locals at a BEGIN" cr
      \ !! print assumption and reality
    then ;
   
 : compile-pushlocal-f ( a-addr -- ) ( run-time: f -- )  : compile-pushlocal-f ( a-addr -- ) ( run-time: f -- )
     locals-size @ alignlp-f float+ dup locals-size !      locals-size @ alignlp-f float+ dup locals-size !
     swap !      swap !
Line 133  variable locals-dp \ so here's the speci Line 261  variable locals-dp \ so here's the speci
     locals-size @ swap !      locals-size @ swap !
     postpone lp@ postpone c! ;      postpone lp@ postpone c! ;
   
 : create-local ( " name" -- a-addr )  7 cells 32 + constant locals-name-size \ 32-char name + fields + wiggle room
         \ defines the local "name"; the offset of the local shall be stored in a-addr  
   : create-local1 ( "name" -- a-addr )
     create      create
         immediate      immediate restrict
         here 0 , ( place for the offset ) ;      here 0 , ( place for the offset ) ;
   
   variable dict-execute-dp \ the special dp for DICT-EXECUTE
   
   0 value dict-execute-ude \ USABLE-DICTIONARY-END during DICT-EXECUTE
   
   : dict-execute1 ( ... addr1 addr2 xt -- ... )
       \ execute xt with HERE set to addr1 and USABLE-DICTIONARY-END set to addr2
       dict-execute-dp @ dp 2>r
       dict-execute-ude ['] usable-dictionary-end defer@ 2>r
       swap to dict-execute-ude
       ['] dict-execute-ude is usable-dictionary-end
       swap to dict-execute-dp
       dict-execute-dp dpp !
       catch
       2r> is usable-dictionary-end to dict-execute-ude
       2r> dpp ! dict-execute-dp !
       throw ;
   
   defer dict-execute ( ... addr1 addr2 xt -- ... )
   
   :noname ( ... addr1 addr2 xt -- ... )
       \ first have a dummy routine, for SOME-CLOCAL etc. below
       nip nip execute ;
   is dict-execute
   
   : create-local ( " name" -- a-addr )
       \ defines the local "name"; the offset of the local shall be
       \ stored in a-addr
       locals-name-size allocate throw
       dup locals-mem-list prepend-list
       locals-name-size cell /string over + ['] create-local1 dict-execute ;
   
   variable locals-dp \ so here's the special dp for locals.
   
 : lp-offset ( n1 -- n2 )  : lp-offset ( n1 -- n2 )
 \ converts the offset from the frame start to an offset from lp and  \ converts the offset from the frame start to an offset from lp and
Line 152  variable locals-dp \ so here's the speci Line 314  variable locals-dp \ so here's the speci
 vocabulary locals-types \ this contains all the type specifyers, -- and }  vocabulary locals-types \ this contains all the type specifyers, -- and }
 locals-types definitions  locals-types definitions
   
 : W:  : W: ( "name" -- a-addr xt ) \ gforth w-colon
     create-local ( "name" -- a-addr xt )      create-local
         \ xt produces the appropriate locals pushing code when executed          \ xt produces the appropriate locals pushing code when executed
         ['] compile-pushlocal-w          ['] compile-pushlocal-w
     does> ( Compilation: -- ) ( Run-time: -- w )      does> ( Compilation: -- ) ( Run-time: -- w )
         \ compiles a local variable access          \ compiles a local variable access
         @ lp-offset compile-@local ;          @ lp-offset compile-@local ;
   
 : W^  : W^ ( "name" -- a-addr xt ) \ gforth w-caret
     create-local ( "name" -- a-addr xt )      create-local
         ['] compile-pushlocal-w          ['] compile-pushlocal-w
     does> ( Compilation: -- ) ( Run-time: -- w )      does> ( Compilation: -- ) ( Run-time: -- w )
         postpone laddr# @ lp-offset, ;          postpone laddr# @ lp-offset, ;
   
 : F:  : F: ( "name" -- a-addr xt ) \ gforth f-colon
     create-local ( "name" -- a-addr xt )      create-local
         ['] compile-pushlocal-f          ['] compile-pushlocal-f
     does> ( Compilation: -- ) ( Run-time: -- w )      does> ( Compilation: -- ) ( Run-time: -- w )
         @ lp-offset compile-f@local ;          @ lp-offset compile-f@local ;
   
 : F^  : F^ ( "name" -- a-addr xt ) \ gforth f-caret
     create-local ( "name" -- a-addr xt )      create-local
         ['] compile-pushlocal-f          ['] compile-pushlocal-f
     does> ( Compilation: -- ) ( Run-time: -- w )      does> ( Compilation: -- ) ( Run-time: -- w )
         postpone laddr# @ lp-offset, ;          postpone laddr# @ lp-offset, ;
   
 : D:  : D: ( "name" -- a-addr xt ) \ gforth d-colon
     create-local ( "name" -- a-addr xt )      create-local
         ['] compile-pushlocal-d          ['] compile-pushlocal-d
     does> ( Compilation: -- ) ( Run-time: -- w )      does> ( Compilation: -- ) ( Run-time: -- w )
         postpone laddr# @ lp-offset, postpone 2@ ;          postpone laddr# @ lp-offset, postpone 2@ ;
   
 : D^  : D^ ( "name" -- a-addr xt ) \ gforth d-caret
     create-local ( "name" -- a-addr xt )      create-local
         ['] compile-pushlocal-d          ['] compile-pushlocal-d
     does> ( Compilation: -- ) ( Run-time: -- w )      does> ( Compilation: -- ) ( Run-time: -- w )
         postpone laddr# @ lp-offset, ;          postpone laddr# @ lp-offset, ;
   
 : C:  : C: ( "name" -- a-addr xt ) \ gforth c-colon
     create-local ( "name" -- a-addr xt )      create-local
         ['] compile-pushlocal-c          ['] compile-pushlocal-c
     does> ( Compilation: -- ) ( Run-time: -- w )      does> ( Compilation: -- ) ( Run-time: -- w )
         postpone laddr# @ lp-offset, postpone c@ ;          postpone laddr# @ lp-offset, postpone c@ ;
   
 : C^  : C^ ( "name" -- a-addr xt ) \ gforth c-caret
     create-local ( "name" -- a-addr xt )      create-local
         ['] compile-pushlocal-c          ['] compile-pushlocal-c
     does> ( Compilation: -- ) ( Run-time: -- w )      does> ( Compilation: -- ) ( Run-time: -- w )
         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
   
   ' dict-execute1 is dict-execute \ now the real thing
       
 \ 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
   
 : new-locals-reveal ( -- )  : new-locals-reveal ( -- )
   true abort" this should not happen: new-locals-reveal" ;    true abort" this should not happen: new-locals-reveal" ;
   
 create new-locals-map ' new-locals-find A, ' new-locals-reveal A,  create new-locals-map ( -- wordlist-map )
   ' new-locals-find A,
 vocabulary new-locals  ' new-locals-reveal A,
 new-locals-map ' new-locals >body cell+ A! \ !! use special access words  ' drop A, \ rehash method
   ' drop A,
 variable old-dpp  
   new-locals-map mappedwordlist Constant new-locals-wl
   
   \ slowvoc @
   \ slowvoc on
   \ vocabulary new-locals
   \ slowvoc !
   \ new-locals-map ' new-locals >body wordlist-map A! \ !! use special access words
   
 \ and now, finally, the user interface words  \ and now, finally, the user interface words
 : { ( -- addr wid 0 )  : { ( -- latestxt wid 0 ) \ gforth open-brace
     dp old-dpp !      latestxt get-current
     locals-dp dpp !      get-order new-locals-wl swap 1+ set-order
     also new-locals      also locals definitions locals-types
     also get-current 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 ... -- )  : } ( latestxt wid 0 a-addr1 xt1 ... -- ) \ gforth close-brace
     \ ends locals definitions      \ ends locals definitions
     ] old-dpp @ dpp !      ]
     begin      begin
         dup          dup
     while      while
Line 257  locals-types definitions Line 445  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 ... -- )  : -- ( addr wid 0 ... -- ) \ gforth dash-dash
     }      }
     [char] } word drop ;      [char] } parse 2drop ;
   
 forth definitions  forth definitions
   
Line 355  forth definitions Line 543  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 kernal.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 ( -- scope )  : scope ( compilation  -- scope ; run-time  -- ) \ gforth
  cs-push-part scopestart ; immediate      cs-push-part scopestart ; immediate
   
 : endscope ( scope -- )  : adjust-locals-list ( wid -- )
  scope?      locals-list @ common-list
  drop      dup list-size adjust-locals-size
  locals-list @ common-list      locals-list ! ;
  dup list-size adjust-locals-size  
  locals-list ! ; immediate  : endscope ( compilation scope -- ; run-time  -- ) \ gforth
       scope?
       drop  adjust-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 !  
     0 locals-list !      0 locals-list !
     dead-code off      dead-code off
     defstart ;      defstart ;
   
   [IFDEF] free-old-local-names
   :noname ( -- )
       locals-mem-list @ free-list
       0 locals-mem-list ! ;
   is free-old-local-names
   [THEN]
   
 : locals-;-hook ( sys addr xt sys -- sys )  : locals-;-hook ( sys addr xt sys -- sys )
     def?      def?
     0 TO locals-wordlist      0 TO locals-wordlist
Line 402  forth definitions Line 585  forth definitions
     lastcfa ! last !      lastcfa ! last !
     DEFERS ;-hook ;      DEFERS ;-hook ;
   
   \ 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>.
   
   : (then-like) ( orig -- )
       dead-orig =
       if
           >resolve drop
       else
           dead-code @
           if
               >resolve set-locals-size-list dead-code off
           else \ both live
               over list-size adjust-locals-size
               >resolve
               adjust-locals-list
           then
       then ;
   
   : (begin-like) ( -- )
       dead-code @ if
           \ set up an assumption of the locals visible here.  if the
           \ users want something to be visible, they have to declare
           \ that using ASSUME-LIVE
           backedge-locals @ set-locals-size-list
       then
       dead-code off ;
   
   \ AGAIN (the current control flow joins another, earlier one):
   \ If the dest-locals-list is not a subset of the current locals-list,
   \ issue a warning (see below). The following code is generated:
   \ lp+!# (current-local-size - dest-locals-size)
   \ branch <begin>
   
   : (again-like) ( dest -- addr )
       over list-size adjust-locals-size
       swap check-begin  POSTPONE unreachable ;
   
   \ UNTIL (the current control flow may join an earlier one or continue):
   \ Similar to AGAIN. The new locals-list and locals-size are the current
   \ ones. The following code is generated:
   \ ?branch-lp+!# <begin> (current-local-size - dest-locals-size)
   
   : (until-like) ( list addr xt1 xt2 -- )
       \ list and addr are a fragment of a cs-item
       \ xt1 is the conditional branch without lp adjustment, xt2 is with
       >r >r
       locals-size @ 2 pick list-size - dup if ( list dest-addr adjustment )
           r> drop r> compile,
           swap <resolve ( list adjustment ) ,
       else ( list dest-addr adjustment )
           drop
           r> compile, <resolve
           r> drop
       then ( list )
       check-begin ;
   
   : (exit-like) ( -- )
       0 adjust-locals-size ;
   
 ' locals-:-hook IS :-hook  ' locals-:-hook IS :-hook
 ' locals-;-hook IS ;-hook  ' locals-;-hook IS ;-hook
   
   
   ' (then-like)  IS then-like
   ' (begin-like) IS begin-like
   ' (again-like) IS again-like
   ' (until-like) IS until-like
   ' (exit-like)  IS exit-like
   
 \ The words in the locals dictionary space are not deleted until the end  \ The words in the locals dictionary space are not deleted until the end
 \ of the current word. This is a bit too conservative, but very simple.  \ of the current word. This is a bit too conservative, but very simple.
   
Line 415  forth definitions Line 674  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 448  forth definitions Line 703  forth definitions
   
 \ And here's finally the ANS standard stuff  \ And here's finally the ANS standard stuff
   
 : (local) ( addr u -- )  : (local) ( addr u -- ) \ local paren-local-paren
     \ a little space-inefficient, but well deserved ;-)      \ a little space-inefficient, but well deserved ;-)
     \ In exchange, there are no restrictions whatsoever on using (local)      \ In exchange, there are no restrictions whatsoever on using (local)
     \ as long as you use it in a definition      \ as long as you use it in a definition
Line 459  forth definitions Line 714  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 [ ' bits >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
         does-code!          swap [ 1 invert ] literal and does-code!
     else      else
         code-address!          code-address!
     then ;      then ;
   
 \ !! untested  : (int-to) ( xt -- ) dup >definer
 : TO ( c|w|d|r "name" -- )      case
 \ !! state smart          [ ' locals-wordlist ] literal >definer \ value
  0 0 0. 0.0e0 { c: clocal w: wlocal d: dlocal f: flocal }          of  >body ! endof
  ' dup >definer          [ ' parse-name ] literal >definer \ defer
  state @           of  defer! endof
  if          -&32 throw
    case      endcase ;
      [ ' locals-wordlist >definer ] literal \ value  
      OF >body POSTPONE Aliteral POSTPONE ! ENDOF  : (comp-to) ( xt -- ) dup >definer
      [ ' clocal >definer ] literal      case
      OF POSTPONE laddr# >body @ lp-offset, POSTPONE c! ENDOF          [ ' locals-wordlist ] literal >definer \ value
      [ ' wlocal >definer ] literal          OF >body POSTPONE Aliteral POSTPONE ! ENDOF
      OF POSTPONE laddr# >body @ lp-offset, POSTPONE ! ENDOF          [ ' parse-name ] literal >definer \ defer
      [ ' dlocal >definer ] literal          OF POSTPONE Aliteral POSTPONE defer! ENDOF
      OF POSTPONE laddr# >body @ lp-offset, POSTPONE d! ENDOF          \ !! dependent on c: etc. being does>-defining words
      [ ' flocal >definer ] literal          \ this works, because >definer uses >does-code in this case,
      OF POSTPONE laddr# >body @ lp-offset, POSTPONE f! ENDOF          \ which produces a relocatable address
      abort" can only store TO value or local value"          [ comp' some-clocal drop ] literal >definer
    endcase          OF POSTPONE laddr# >body @ lp-offset, POSTPONE c! ENDOF
  else          [ comp' some-wlocal drop ] literal >definer
    [ ' locals-wordlist >definer ] literal =          OF POSTPONE laddr# >body @ lp-offset, POSTPONE ! ENDOF
    if          [ comp' some-dlocal drop ] literal >definer
      >body !          OF POSTPONE laddr# >body @ lp-offset, POSTPONE 2! ENDOF
    else          [ comp' some-flocal drop ] literal >definer
      abort" can only store TO value"          OF POSTPONE laddr# >body @ lp-offset, POSTPONE f! ENDOF
    endif          -&32 throw
  endif ; immediate      endcase ;
   
 : locals|  :noname
   BEGIN  sname 2dup s" |" compare 0=  WHILE      ' (int-to) ;
          (local)  REPEAT  drop 0 (local) ;  immediate restrict  :noname
       comp' drop (comp-to) ;
   interpret/compile: TO ( c|w|d|r "name" -- ) \ core-ext,local
   
   : locals| ( ... "name ..." -- ) \ local-ext locals-bar
       \ don't use 'locals|'! use '{'! A portable and free '{'
       \ implementation is compat/anslocals.fs
       BEGIN
           name 2dup s" |" str= 0=
       WHILE
           (local)
       REPEAT
       drop 0 (local) ; immediate restrict

Removed from v.1.6  
changed lines
  Added in v.1.69


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