--- gforth/glocals.fs 1995/04/06 16:56:12 1.10 +++ gforth/glocals.fs 2004/09/17 14:53:28 1.54 @@ -1,3 +1,27 @@ +\ A powerful locals implementation + +\ Copyright (C) 1995,1996,1997,1998,2000,2003 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 2 +\ 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, write to the Free Software +\ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. + + +\ 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 \ IMO (anton) they are the worst part of the standard. There they are very \ restricted and have an ugly interface. @@ -61,10 +85,11 @@ \ Currently locals may only be \ defined at the outer level and TO is not supported. -include search-order.fs -include float.fs +require search.fs +require float.fs +require extend.fs \ for case -: compile-@local ( n -- ) \ new compile-fetch-local +: compile-@local ( n -- ) \ gforth compile-fetch-local case 0 of postpone @local0 endof 1 cells of postpone @local1 endof @@ -73,13 +98,28 @@ include float.fs ( otherwise ) dup postpone @local# , endcase ; -: compile-f@local ( n -- ) \ new compile-f-fetch-local +: compile-f@local ( n -- ) \ gforth compile-f-fetch-local case 0 of postpone f@local0 endof 1 floats of postpone f@local1 endof ( otherwise ) dup postpone f@local# , 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) \ 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. @@ -90,7 +130,7 @@ include float.fs slowvoc @ slowvoc on \ we want a linked list for the vocabulary locals vocabulary locals \ this contains the local variables -' locals >body ' locals-list >body ! +' locals >body wordlist-id ' locals-list >body ! slowvoc ! create locals-buffer 1000 allot \ !! limited and unsafe @@ -118,6 +158,55 @@ variable locals-dp \ so here's the speci swap ! postpone >l ; +\ locals list operations + +: common-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 ; + +: sub-list? ( list1 list2 -- f ) \ gforth-internal +\ true iff list1 is a sublist of list2 + begin + 2dup u< + while + @ + repeat + = ; + +: 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 + ." compiler was overly optimistic about locals at a BEGIN" cr + \ !! print assumption and reality + then ; + : compile-pushlocal-f ( a-addr -- ) ( run-time: f -- ) locals-size @ alignlp-f float+ dup locals-size ! swap ! @@ -137,7 +226,7 @@ variable locals-dp \ so here's the speci \ defines the local "name"; the offset of the local shall be \ stored in a-addr create - immediate + immediate restrict here 0 , ( place for the offset ) ; : lp-offset ( n1 -- n2 ) @@ -153,102 +242,131 @@ variable locals-dp \ so here's the speci vocabulary locals-types \ this contains all the type specifyers, -- and } locals-types definitions -: W: - create-local ( "name" -- a-addr xt ) +: W: ( "name" -- a-addr xt ) \ gforth w-colon + create-local \ xt produces the appropriate locals pushing code when executed ['] compile-pushlocal-w does> ( Compilation: -- ) ( Run-time: -- w ) \ compiles a local variable access @ lp-offset compile-@local ; -: W^ - create-local ( "name" -- a-addr xt ) +: W^ ( "name" -- a-addr xt ) \ gforth w-caret + create-local ['] compile-pushlocal-w does> ( Compilation: -- ) ( Run-time: -- w ) postpone laddr# @ lp-offset, ; -: F: - create-local ( "name" -- a-addr xt ) +: F: ( "name" -- a-addr xt ) \ gforth f-colon + create-local ['] compile-pushlocal-f does> ( Compilation: -- ) ( Run-time: -- w ) @ lp-offset compile-f@local ; -: F^ - create-local ( "name" -- a-addr xt ) +: F^ ( "name" -- a-addr xt ) \ gforth f-caret + create-local ['] compile-pushlocal-f does> ( Compilation: -- ) ( Run-time: -- w ) postpone laddr# @ lp-offset, ; -: D: - create-local ( "name" -- a-addr xt ) +: D: ( "name" -- a-addr xt ) \ gforth d-colon + create-local ['] compile-pushlocal-d does> ( Compilation: -- ) ( Run-time: -- w ) postpone laddr# @ lp-offset, postpone 2@ ; -: D^ - create-local ( "name" -- a-addr xt ) +: D^ ( "name" -- a-addr xt ) \ gforth d-caret + create-local ['] compile-pushlocal-d does> ( Compilation: -- ) ( Run-time: -- w ) postpone laddr# @ lp-offset, ; -: C: - create-local ( "name" -- a-addr xt ) +: C: ( "name" -- a-addr xt ) \ gforth c-colon + create-local ['] compile-pushlocal-c does> ( Compilation: -- ) ( Run-time: -- w ) postpone laddr# @ lp-offset, postpone c@ ; -: C^ - create-local ( "name" -- a-addr xt ) +: C^ ( "name" -- a-addr xt ) \ gforth c-caret + create-local ['] compile-pushlocal-c does> ( Compilation: -- ) ( Run-time: -- w ) postpone laddr# @ lp-offset, ; \ you may want to make comments in a locals definitions group: -' \ alias \ immediate -' ( alias ( immediate +' \ alias \ ( compilation 'ccc' -- ; run-time -- ) \ core-ext,block-ext backslash +\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' -- ; 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 +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. \ we exploit a feature of our dictionary: every wordlist \ has it's own methods for finding words etc. \ So we create a vocabulary new-locals, that creates a 'w:' local named x \ when it is asked if it contains x. -also locals-types - : new-locals-find ( caddr u w -- nfa ) \ this is the find method of the new-locals vocabulary \ make a new local with name caddr u; w is ignored \ the returned nfa denotes a word that produces what W: produces \ !! do the whole thing without nextname drop nextname - ['] W: >name ; + ['] W: >head-noprim ; previous : new-locals-reveal ( -- ) true abort" this should not happen: new-locals-reveal" ; -create new-locals-map ' new-locals-find A, ' new-locals-reveal A, - -vocabulary new-locals -new-locals-map ' new-locals >body cell+ A! \ !! use special access words +create new-locals-map ( -- wordlist-map ) +' new-locals-find A, +' new-locals-reveal A, +' drop A, \ rehash method +' drop A, + +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 variable old-dpp \ and now, finally, the user interface words -: { ( -- addr wid 0 ) +: { ( -- latestxt wid 0 ) \ gforth open-brace dp old-dpp ! locals-dp dpp ! - also new-locals - also get-current locals definitions locals-types + latestxt get-current + get-order new-locals-wl swap 1+ set-order + also locals definitions locals-types 0 TO locals-wordlist 0 postpone [ ; immediate locals-types definitions -: } ( addr wid 0 a-addr1 xt1 ... -- ) +: } ( latestxt wid 0 a-addr1 xt1 ... -- ) \ gforth close-brace \ ends locals definitions ] old-dpp @ dpp ! begin @@ -258,11 +376,11 @@ locals-types definitions repeat drop locals-size @ alignlp-f locals-size ! \ the strictest alignment - set-current 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] } parse 2drop ; @@ -356,39 +474,28 @@ forth definitions \ If this assumption is too optimistic, the compiler will warn the user. -\ Implementation: migrated to kernal.fs - -\ 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) -\ : -\ 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 . +\ Implementation: \ explicit scoping -: scope ( -- scope ) - cs-push-part scopestart ; immediate +: scope ( compilation -- scope ; run-time -- ) \ gforth + cs-push-part scopestart ; immediate -: endscope ( scope -- ) - scope? - drop - locals-list @ common-list - dup list-size adjust-locals-size - locals-list ! ; immediate +: adjust-locals-list ( wid -- ) + locals-list @ common-list + dup list-size adjust-locals-size + locals-list ! ; + +: endscope ( compilation scope -- ; run-time -- ) \ gforth + scope? + drop adjust-locals-list ; immediate \ adapt the hooks : locals-:-hook ( sys -- sys addr xt n ) \ addr is the nfa of the defined word, xt its xt DEFERS :-hook - last @ lastcfa @ + latest latestxt clear-leave-stack 0 locals-size ! locals-buffer locals-dp ! @@ -403,9 +510,84 @@ forth definitions lastcfa ! last ! 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) +\ : +\ 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-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 + +: (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+!# (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 compile, drop + then ( list ) + check-begin ; + +: (exit-like) ( -- ) + 0 adjust-locals-size ; + ' 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 \ of the current word. This is a bit too conservative, but very simple. @@ -416,10 +598,6 @@ forth definitions \ things above are not control flow joins. Everything should be taken \ 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: \ 1) Do not complain (After all, this is Forth;-) @@ -449,7 +627,7 @@ forth definitions \ 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 ;-) \ In exchange, there are no restrictions whatsoever on using (local) \ as long as you use it in a definition @@ -461,58 +639,59 @@ forth definitions endif ; : >definer ( xt -- definer ) - \ this gives a unique identifier for the way the xt was defined - \ words defined with different does>-codes have different definers - \ the definer can be used for comparison and in definer! - dup >code-address [ ' bits >code-address ] Literal = - \ !! this definition will not work on some implementations for `bits' - if \ if >code-address delivers the same value for all does>-def'd words - >does-code 1 or \ bit 0 marks special treatment for does codes + \G @var{Definer} is a unique identifier for the way the @var{xt} + \G was defined. Words defined with different @code{does>}-codes + \G have different definers. The definer can be used for + \G comparison and in @code{definer!}. + dup >does-code + ?dup-if + nip 1 or else >code-address then ; : definer! ( definer xt -- ) - \ 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 - does-code! + swap [ 1 invert ] literal and does-code! else code-address! then ; -\ !! untested -: TO ( c|w|d|r "name" -- ) -\ !! state smart - 0 0 0. 0.0e0 { c: clocal w: wlocal d: dlocal f: flocal } - ' dup >definer - state @ - if - case - [ ' locals-wordlist >definer ] literal \ value - OF >body POSTPONE Aliteral POSTPONE ! ENDOF - [ ' clocal >definer ] literal - OF POSTPONE laddr# >body @ lp-offset, POSTPONE c! ENDOF - [ ' wlocal >definer ] literal - OF POSTPONE laddr# >body @ lp-offset, POSTPONE ! ENDOF - [ ' dlocal >definer ] literal - OF POSTPONE laddr# >body @ lp-offset, POSTPONE d! ENDOF - [ ' flocal >definer ] literal - OF POSTPONE laddr# >body @ lp-offset, POSTPONE f! ENDOF - abort" can only store TO value or local value" - endcase - else - [ ' locals-wordlist >definer ] literal = - if - >body ! - else - abort" can only store TO value" - endif - endif ; immediate +:noname + ' dup >definer [ ' locals-wordlist ] literal >definer = + if + >body ! + else + -&32 throw + endif ; +:noname + comp' drop dup >definer + case + [ ' locals-wordlist ] literal >definer \ value + OF >body POSTPONE Aliteral POSTPONE ! ENDOF + \ !! 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 + [ comp' some-wlocal drop ] literal >definer + OF POSTPONE laddr# >body @ lp-offset, POSTPONE ! ENDOF + [ comp' some-dlocal drop ] literal >definer + OF POSTPONE laddr# >body @ lp-offset, POSTPONE 2! ENDOF + [ comp' some-flocal drop ] literal >definer + OF POSTPONE laddr# >body @ lp-offset, POSTPONE f! ENDOF + -&32 throw + endcase ; +interpret/compile: TO ( c|w|d|r "name" -- ) \ core-ext,local : locals| + \ don't use 'locals|'! use '{'! A portable and free '{' + \ implementation is compat/anslocals.fs BEGIN - name 2dup s" |" compare 0<> + name 2dup s" |" str= 0= WHILE (local) REPEAT - drop 0 (local) ; immediate restrict + drop 0 (local) ; immediate restrict