version 1.7, 1994/09/12 19:00:30
|
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 search-order.fs |
|
include float.fs |
|
|
|
: compile-@local ( n -- ) |
: compile-@local ( n -- ) \ gforth compile-fetch-local |
case |
case |
0 of postpone @local0 endof |
0 of postpone @local0 endof |
1 cells of postpone @local1 endof |
1 cells of postpone @local1 endof |
Line 73 include float.fs
|
Line 92 include float.fs
|
( 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 |
1 floats of postpone f@local1 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 float.fs
|
Line 124 include 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 |
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 name 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 |