version 1.5, 1994/07/21 10:52:49
|
version 1.57, 2000/12/26 19:31:56
|
Line 1
|
Line 1
|
|
\ converts primitives to, e.g., C code |
|
|
|
\ Copyright (C) 1995,1996,1997,1998,2000 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. |
|
|
|
|
\ This is not very nice (hard limits, no checking, assumes 1 chars = 1) |
\ This is not very nice (hard limits, no checking, assumes 1 chars = 1) |
|
|
\ Optimizations: |
\ Optimizations: |
Line 21
|
Line 42
|
|
|
warnings off |
warnings off |
|
|
[IFUNDEF] vocabulary include search-order.fs [THEN] |
[IFUNDEF] vocabulary \ we are executed just with kernel image |
include gray.fs |
\ load the rest that is needed |
|
\ (require fails because this file is needed from a |
|
\ different directory with the wordlibraries) |
|
include ./search.fs |
|
include ./extend.fs |
|
[THEN] |
|
|
|
[IFUNDEF] environment? |
|
include ./environ.fs |
|
[THEN] |
|
|
|
: struct% struct ; \ struct is redefined in gray |
|
|
|
include ./gray.fs |
|
|
100 constant max-effect \ number of things on one side of a stack effect |
100 constant max-effect \ number of things on one side of a stack effect |
4096 constant batch-size \ no meaning, just make sure it's >0 |
|
255 constant maxchar |
255 constant maxchar |
maxchar 1+ constant eof-char |
maxchar 1+ constant eof-char |
9 constant tab-char |
#tab constant tab-char |
10 constant nl-char |
#lf constant nl-char |
|
|
: read-whole-file ( c-addr1 file-id -- c-addr2 ) |
variable rawinput \ pointer to next character to be scanned |
\ reads the contents of the file file-id puts it into memory at c-addr1 |
variable endrawinput \ pointer to the end of the input (the char after the last) |
\ c-addr2 is the first address after the file block |
variable cookedinput \ pointer to the next char to be parsed |
begin ( c-addr file-id ) |
variable line \ line number of char pointed to by input |
2dup batch-size swap read-file |
1 line ! |
if |
2variable filename \ filename of original input file |
abort" I/O error" |
0 0 filename 2! |
endif |
2variable f-comment |
( c-addr file-id actual-size ) rot over + -rot |
0 0 f-comment 2! |
batch-size <> |
variable skipsynclines \ are sync lines ("#line ...") invisible to the parser? |
until |
skipsynclines on |
drop ; |
|
|
|
variable input \ pointer to next character to be parsed |
|
variable endinput \ pointer to the end of the input (the char after the last) |
|
|
|
: start ( -- addr ) |
: start ( -- addr ) |
input @ ; |
cookedinput @ ; |
|
|
: end ( addr -- addr u ) |
: end ( addr -- addr u ) |
input @ over - ; |
cookedinput @ over - ; |
|
|
variable output \ xt ( -- ) of output word |
variable output \ xt ( -- ) of output word |
|
|
: printprim ( -- ) |
: printprim ( -- ) |
output @ execute ; |
output @ execute ; |
|
|
: field |
struct% |
<builds-field ( n1 n2 -- n3 ) |
cell% 2* field stack-pointer \ stackpointer name |
does> ( addr1 -- addr2 ) |
cell% 2* field stack-cast \ cast string for assignments to stack elements |
@ + ; |
cell% field stack-in-index-xt \ ( in-size item -- in-index ) |
|
cell% field stack-in \ number of stack items in effect in |
: const-field |
cell% field stack-out \ number of stack items in effect out |
<builds-field ( n1 n2 -- n3 ) |
end-struct stack% |
does> ( addr -- w ) |
|
@ + @ ; |
struct% |
|
cell% 2* field item-name \ name, excluding stack prefixes |
struct |
cell% field item-stack \ descriptor for the stack used, 0 is default |
2 cells field item-name |
cell% field item-type \ descriptor for the item type |
cell field item-d-offset |
cell% field item-offset \ offset in stack items, 0 for the deepest element |
cell field item-f-offset |
end-struct item% |
cell field item-type |
|
constant item-descr |
struct% |
|
cell% 2* field type-c-name |
|
cell% field type-stack \ default stack |
|
cell% field type-size \ size of type in stack items |
|
cell% field type-fetch \ xt of fetch code generator ( item -- ) |
|
cell% field type-store \ xt of store code generator ( item -- ) |
|
end-struct type% |
|
|
|
: stack-in-index ( in-size item -- in-index ) |
|
item-offset @ - 1- ; |
|
|
|
: inst-in-index ( in-size item -- in-index ) |
|
nip dup item-offset @ swap item-type @ type-size @ + 1- ; |
|
|
|
: make-stack ( addr-ptr u1 addr-cast u2 "stack-name" -- ) |
|
create stack% %allot >r |
|
save-mem r@ stack-cast 2! |
|
save-mem r@ stack-pointer 2! |
|
['] stack-in-index r> stack-in-index-xt ! ; |
|
|
|
s" sp" save-mem s" (Cell)" make-stack data-stack |
|
s" fp" save-mem s" " make-stack fp-stack |
|
s" rp" save-mem s" (Cell)" make-stack return-stack |
|
s" ip" save-mem s" error don't use # on results" make-stack inst-stream |
|
' inst-in-index inst-stream stack-in-index-xt ! |
|
\ !! initialize stack-in and stack-out |
|
|
|
\ stack items |
|
|
|
: init-item ( addr u addr1 -- ) |
|
\ initialize item at addr1 with name addr u |
|
\ !! remove stack prefix |
|
dup item% %size erase |
|
item-name 2! ; |
|
|
|
\ various variables for storing stuff of one primitive |
|
|
2variable forth-name |
2variable forth-name |
2variable wordset |
2variable wordset |
Line 82 constant item-descr
|
Line 146 constant item-descr
|
2variable c-code |
2variable c-code |
2variable forth-code |
2variable forth-code |
2variable stack-string |
2variable stack-string |
create effect-in max-effect item-descr * allot |
create effect-in max-effect item% %size * allot |
create effect-out max-effect item-descr * allot |
create effect-out max-effect item% %size * allot |
variable effect-in-end ( pointer ) |
variable effect-in-end ( pointer ) |
variable effect-out-end ( pointer ) |
variable effect-out-end ( pointer ) |
2variable effect-in-size |
variable c-line |
2variable effect-out-size |
2variable c-filename |
|
variable name-line |
|
2variable name-filename |
|
2variable last-name-filename |
|
|
variable primitive-number -8 primitive-number ! |
variable primitive-number -10 primitive-number ! |
|
Variable function-number 0 function-number ! |
|
|
\ for several reasons stack items of a word are stored in a wordlist |
\ for several reasons stack items of a word are stored in a wordlist |
\ since neither forget nor marker are implemented yet, we make a new |
\ since neither forget nor marker are implemented yet, we make a new |
Line 109 variable items
|
Line 177 variable items
|
eof-char max-member \ the whole character set + EOF |
eof-char max-member \ the whole character set + EOF |
|
|
: getinput ( -- n ) |
: getinput ( -- n ) |
input @ |
rawinput @ endrawinput @ = |
dup endinput @ = |
|
if |
if |
drop eof-char |
eof-char |
else |
else |
c@ |
cookedinput @ c@ |
endif ; |
endif ; |
|
|
:noname ( n -- ) |
:noname ( n -- ) |
Line 129 print-token !
|
Line 196 print-token !
|
getinput member? ; |
getinput member? ; |
' testchar? test-vector ! |
' testchar? test-vector ! |
|
|
|
: checksyncline ( -- ) |
|
\ when input points to a newline, check if the next line is a |
|
\ sync line. If it is, perform the appropriate actions. |
|
rawinput @ >r |
|
s" #line " r@ over compare 0<> if |
|
rdrop 1 line +! EXIT |
|
endif |
|
0. r> 6 chars + 20 >number drop >r drop line ! r> ( c-addr ) |
|
dup c@ bl = if |
|
char+ dup c@ [char] " <> abort" sync line syntax" |
|
char+ dup 100 [char] " scan drop swap 2dup - save-mem filename 2! |
|
char+ |
|
endif |
|
dup c@ nl-char <> abort" sync line syntax" |
|
skipsynclines @ if |
|
dup char+ rawinput ! |
|
rawinput @ c@ cookedinput @ c! |
|
endif |
|
drop ; |
|
|
: ?nextchar ( f -- ) |
: ?nextchar ( f -- ) |
?not? if |
?not? if |
." syntax error" cr |
filename 2@ type ." :" line @ 0 .r ." : syntax error, wrong char:" |
getinput . cr |
getinput . cr |
input @ endinput @ over - 100 min type cr |
rawinput @ endrawinput @ over - 100 min type cr |
abort |
abort |
endif |
endif |
input @ endinput @ <> if |
rawinput @ endrawinput @ <> if |
1 input +! |
rawinput @ c@ |
endif ; |
1 chars rawinput +! |
|
1 chars cookedinput +! |
|
nl-char = if |
|
checksyncline |
|
endif |
|
rawinput @ c@ cookedinput @ c! |
|
endif ; |
|
|
: charclass ( set "name" -- ) |
: charclass ( set "name" -- ) |
['] ?nextchar terminal ; |
['] ?nextchar terminal ; |
Line 152 print-token !
|
Line 245 print-token !
|
|
|
: ` ( -- terminal ) ( use: ` c ) |
: ` ( -- terminal ) ( use: ` c ) |
( creates anonymous terminal for the character c ) |
( creates anonymous terminal for the character c ) |
[compile] ascii singleton ['] ?nextchar make-terminal ; |
char singleton ['] ?nextchar make-terminal ; |
|
|
char a char z .. char A char Z .. union char _ singleton union charclass letter |
char a char z .. char A char Z .. union char _ singleton union charclass letter |
char 0 char 9 .. charclass digit |
char 0 char 9 .. charclass digit |
bl singleton charclass blank |
bl singleton tab-char over add-member charclass white |
tab-char singleton charclass tab |
|
nl-char singleton eof-char over add-member complement charclass nonl |
nl-char singleton eof-char over add-member complement charclass nonl |
nl-char singleton eof-char over add-member char : over add-member complement charclass nocolonnl |
nl-char singleton eof-char over add-member |
bl 1+ maxchar .. charclass nowhite |
char : over add-member complement charclass nocolonnl |
|
bl 1+ maxchar .. char \ singleton complement intersection |
|
charclass nowhitebq |
|
bl 1+ maxchar .. charclass nowhite |
char " singleton eof-char over add-member complement charclass noquote |
char " singleton eof-char over add-member complement charclass noquote |
nl-char singleton charclass nl |
nl-char singleton charclass nl |
eof-char singleton charclass eof |
eof-char singleton charclass eof |
|
|
|
|
(( letter (( letter || digit )) ** |
(( letter (( letter || digit )) ** |
)) <- c-name ( -- ) |
)) <- c-ident ( -- ) |
|
|
nowhite ++ |
(( ` # ?? (( letter || digit || ` : )) ** |
<- name ( -- ) |
)) <- stack-ident ( -- ) |
|
|
(( ` \ nonl ** nl |
(( nowhitebq nowhite ** )) |
)) <- comment ( -- ) |
<- forth-ident ( -- ) |
|
|
(( {{ effect-in }} (( {{ start }} c-name {{ end 2 pick item-name 2! item-descr + }} blank ** )) ** {{ effect-in-end ! }} |
Variable forth-flag |
` - ` - blank ** |
Variable c-flag |
{{ effect-out }} (( {{ start }} c-name {{ end 2 pick item-name 2! item-descr + }} blank ** )) ** {{ effect-out-end ! }} |
|
|
(( (( ` e || ` E )) {{ start }} nonl ** |
|
{{ end evaluate }} |
|
)) <- eval-comment ( ... -- ... ) |
|
|
|
(( (( ` f || ` F )) {{ start }} nonl ** |
|
{{ end forth-flag @ IF type cr ELSE 2drop THEN }} |
|
)) <- forth-comment ( -- ) |
|
|
|
(( (( ` c || ` C )) {{ start }} nonl ** |
|
{{ end c-flag @ IF type cr ELSE 2drop THEN }} |
|
)) <- c-comment ( -- ) |
|
|
|
(( ` - nonl ** {{ |
|
forth-flag @ IF ." [ELSE]" cr THEN |
|
c-flag @ IF ." #else" cr THEN }} |
|
)) <- else-comment |
|
|
|
(( ` + {{ start }} nonl ** {{ end |
|
dup |
|
IF c-flag @ |
|
IF ." #ifdef HAS_" bounds ?DO I c@ toupper emit LOOP cr |
|
THEN |
|
forth-flag @ |
|
IF ." has? " type ." [IF]" cr THEN |
|
ELSE 2drop |
|
c-flag @ IF ." #endif" cr THEN |
|
forth-flag @ IF ." [THEN]" cr THEN |
|
THEN }} |
|
)) <- if-comment |
|
|
|
(( (( eval-comment || forth-comment || c-comment || else-comment || if-comment )) ?? nonl ** )) <- comment-body |
|
|
|
(( ` \ comment-body nl )) <- comment ( -- ) |
|
|
|
(( {{ start }} stack-ident {{ end 2 pick init-item item% %size + }} white ** )) ** |
|
<- stack-items |
|
|
|
(( {{ effect-in }} stack-items {{ effect-in-end ! }} |
|
` - ` - white ** |
|
{{ effect-out }} stack-items {{ effect-out-end ! }} |
)) <- stack-effect ( -- ) |
)) <- stack-effect ( -- ) |
|
|
(( {{ s" " doc 2! s" " forth-code 2! }} |
(( {{ s" " doc 2! s" " forth-code 2! s" " wordset 2! }} |
(( comment || nl )) ** |
(( {{ line @ name-line ! filename 2@ name-filename 2! }} |
(( {{ start }} name {{ end 2dup forth-name 2! c-name 2! }} tab ++ |
{{ start }} forth-ident {{ end 2dup forth-name 2! c-name 2! }} white ++ |
{{ start }} stack-effect {{ end stack-string 2! }} tab ++ |
` ( white ** {{ start }} stack-effect {{ end stack-string 2! }} ` ) white ** |
{{ start }} name {{ end wordset 2! }} tab ** |
(( {{ start }} forth-ident {{ end wordset 2! }} white ** |
(( {{ start }} c-name {{ end c-name 2! }} )) ?? nl |
(( {{ start }} c-ident {{ end c-name 2! }} )) ?? |
|
)) ?? nl |
)) |
)) |
(( ` " ` " {{ start }} (( noquote ++ ` " )) ++ {{ end 1- doc 2! }} ` " nl )) ?? |
(( ` " ` " {{ start }} (( noquote ++ ` " )) ++ {{ end 1- doc 2! }} ` " nl )) ?? |
{{ start }} (( nocolonnl nonl ** nl )) ** {{ end c-code 2! }} |
{{ skipsynclines off line @ c-line ! filename 2@ c-filename 2! start }} (( nocolonnl nonl ** nl )) ** {{ end c-code 2! skipsynclines on }} |
(( ` : nl |
(( ` : nl |
{{ start }} (( nonl ++ nl )) ++ {{ end forth-code 2! }} |
{{ start }} (( nonl ++ nl )) ++ {{ end forth-code 2! }} |
)) ?? |
)) ?? {{ printprim }} |
(( nl || eof )) |
(( nl || eof )) |
)) <- primitive ( -- ) |
)) <- primitive ( -- ) |
|
|
(( (( primitive {{ printprim }} )) ** eof )) |
(( (( comment || primitive || nl )) ** eof )) |
parser primitives2something |
parser primitives2something |
warnings @ [IF] |
warnings @ [IF] |
.( parser generated ok ) cr |
.( parser generated ok ) cr |
Line 204 warnings @ [IF]
|
Line 340 warnings @ [IF]
|
: primfilter ( file-id xt -- ) |
: primfilter ( file-id xt -- ) |
\ fileid is for the input file, xt ( -- ) is for the output word |
\ fileid is for the input file, xt ( -- ) is for the output word |
output ! |
output ! |
here input ! |
here dup rawinput ! cookedinput ! |
here swap read-whole-file |
here unused rot read-file throw |
dup endinput ! |
dup here + endrawinput ! |
here - allot |
allot |
align |
align |
|
checksyncline |
|
\ begin |
|
\ getinput dup eof-char = ?EXIT emit true ?nextchar |
|
\ again ; |
primitives2something ; |
primitives2something ; |
|
|
\ types |
\ types |
|
|
struct |
: stack-access ( n stack -- ) |
2 cells field type-c-name |
\ print a stack access at index n of stack |
cell const-field type-d-size |
stack-pointer 2@ type |
cell const-field type-f-size |
dup |
cell const-field type-fetch-handler |
if |
cell const-field type-store-handler |
." [" 0 .r ." ]" |
constant type-description |
else |
|
drop ." TOS" |
: data-stack-access ( n1 n2 n3 -- ) |
endif ; |
\ n1 is the offset of the accessed item, n2, n3 are effect-*-size |
|
drop swap - 1- dup |
: item-in-index { item -- n } |
if |
\ n is the index of item (in the in-effect) |
." sp[" 0 .r ." ]" |
item item-stack @ dup >r stack-in @ ( in-size r:stack ) |
else |
item r> stack-in-index-xt @ execute ; |
drop ." TOS" |
|
endif ; |
|
|
|
: fp-stack-access ( n1 n2 n3 -- ) |
|
\ n1 is the offset of the accessed item, n2, n3 are effect-*-size |
|
nip swap - 1- dup |
|
if |
|
." fp[" 0 .r ." ]" |
|
else |
|
drop ." FTOS" |
|
endif ; |
|
|
|
: fetch-single ( item -- ) |
: fetch-single ( item -- ) |
|
\ fetch a single stack item from its stack |
>r |
>r |
r@ item-name 2@ type ." = (" |
r@ item-name 2@ type |
|
." = (" |
r@ item-type @ type-c-name 2@ type ." ) " |
r@ item-type @ type-c-name 2@ type ." ) " |
r@ item-d-offset @ effect-in-size 2@ data-stack-access ." ;" cr |
r@ item-in-index r@ item-stack @ stack-access |
|
." ;" cr |
rdrop ; |
rdrop ; |
|
|
: fetch-double ( item -- ) |
: fetch-double ( item -- ) |
|
\ fetch a double stack item from its stack |
>r |
>r |
." {Double_Store _d; _d.cells.low = " |
." FETCH_DCELL(" |
r@ item-d-offset @ dup effect-in-size 2@ data-stack-access |
r@ item-name 2@ type ." , " |
." ; _d.cells.high = " 1+ effect-in-size 2@ data-stack-access ." ; " |
r@ item-in-index r@ item-stack @ 2dup stack-access |
r@ item-name 2@ type ." = _d.dcell;}" cr |
." , " -1 under+ stack-access |
rdrop ; |
." );" cr |
|
|
: fetch-float ( item -- ) |
|
>r |
|
r@ item-name 2@ type ." = " |
|
\ ." (" r@ item-type @ type-c-name 2@ type ." ) " |
|
r@ item-f-offset @ effect-in-size 2@ fp-stack-access ." ;" cr |
|
rdrop ; |
rdrop ; |
|
|
: d-same-as-in? ( item -- f ) |
: same-as-in? ( item -- f ) |
\ f is true iff the offset of item is the same as on input |
\ f is true iff the offset and stack of item is the same as on input |
>r |
>r |
r@ item-name 2@ items @ search-wordlist 0= |
r@ item-name 2@ items @ search-wordlist 0= |
if |
abort" bug" |
." bug" cr abort |
|
endif |
|
execute @ |
execute @ |
dup r@ = |
dup r@ = |
if \ item first appeared in output |
if \ item first appeared in output |
drop false |
drop false |
else |
else |
item-d-offset @ r@ item-d-offset @ = |
dup item-stack @ r@ item-stack @ = |
|
swap item-offset @ r@ item-offset @ = and |
endif |
endif |
rdrop ; |
rdrop ; |
|
|
: is-in-tos? ( item -- f ) |
: item-out-index ( item -- n ) |
\ true if item has the same offset as the input TOS |
\ n is the index of item (in the in-effect) |
item-d-offset @ 1+ effect-in-size 2@ drop = ; |
>r r@ item-stack @ stack-out @ r> item-offset @ - 1- ; |
|
|
: really-store-single ( item -- ) |
: really-store-single ( item -- ) |
>r |
>r |
r@ item-d-offset @ effect-out-size 2@ data-stack-access ." = (Cell)" |
r@ item-out-index r@ item-stack @ stack-access ." = " |
|
r@ item-stack @ stack-cast 2@ type |
r@ item-name 2@ type ." ;" |
r@ item-name 2@ type ." ;" |
rdrop ; |
rdrop ; |
|
|
: store-single ( item -- ) |
: store-single ( item -- ) |
>r |
>r |
r@ d-same-as-in? |
r@ same-as-in? |
if |
if |
r@ is-in-tos? |
r@ item-in-index 0= r@ item-out-index 0= xor |
if |
if |
." IF_TOS(" r@ really-store-single ." );" cr |
." IF_" r@ item-stack @ stack-pointer 2@ type |
|
." TOS(" r@ really-store-single ." );" cr |
endif |
endif |
else |
else |
r@ really-store-single cr |
r@ really-store-single cr |
Line 303 constant type-description
|
Line 431 constant type-description
|
: store-double ( item -- ) |
: store-double ( item -- ) |
\ !! store optimization is not performed, because it is not yet needed |
\ !! store optimization is not performed, because it is not yet needed |
>r |
>r |
." {Double_Store _d; _d.dcell = " r@ item-name 2@ type ." ; " |
." STORE_DCELL(" r@ item-name 2@ type ." , " |
r@ item-d-offset @ dup effect-out-size 2@ data-stack-access |
r@ item-out-index r@ item-stack @ 2dup stack-access |
." = _d.cells.low; " 1+ effect-out-size 2@ data-stack-access |
." , " -1 under+ stack-access |
." = _d.cells.high;}" cr |
." );" cr |
rdrop ; |
rdrop ; |
|
|
: f-same-as-in? ( item -- f ) |
: single ( -- xt1 xt2 n ) |
\ f is true iff the offset of item is the same as on input |
['] fetch-single ['] store-single 1 ; |
>r |
|
r@ item-name 2@ items @ search-wordlist 0= |
|
if |
|
." bug" cr abort |
|
endif |
|
execute @ |
|
dup r@ = |
|
if \ item first appeared in output |
|
drop false |
|
else |
|
item-f-offset @ r@ item-f-offset @ = |
|
endif |
|
rdrop ; |
|
|
|
: is-in-ftos? ( item -- f ) |
|
\ true if item has the same offset as the input TOS |
|
item-f-offset @ 1+ effect-in-size 2@ nip = ; |
|
|
|
: really-store-float ( item -- ) |
|
>r |
|
r@ item-f-offset @ effect-out-size 2@ fp-stack-access ." = " |
|
r@ item-name 2@ type ." ;" |
|
rdrop ; |
|
|
|
: store-float ( item -- ) |
|
>r |
|
r@ f-same-as-in? |
|
if |
|
r@ is-in-ftos? |
|
if |
|
." IF_FTOS(" r@ really-store-float ." );" cr |
|
endif |
|
else |
|
r@ really-store-float cr |
|
endif |
|
rdrop ; |
|
|
|
: single-type ( -- xt n1 n2 ) |
|
['] fetch-single ['] store-single 1 0 ; |
|
|
|
: double-type ( -- xt n1 n2 ) |
|
['] fetch-double ['] store-double 2 0 ; |
|
|
|
: float-type ( -- xt n1 n2 ) |
: double ( -- xt1 xt2 n ) |
['] fetch-float ['] store-float 0 1 ; |
['] fetch-double ['] store-double 2 ; |
|
|
: s, ( addr u -- ) |
: s, ( addr u -- ) |
\ allocate a string |
\ allocate a string |
here swap dup allot move ; |
here swap dup allot move ; |
|
|
: starts-with ( addr u xt1 xt2 n1 n2 "prefix" -- ) |
wordlist constant prefixes |
\ describes a type |
|
\ addr u specifies the C type name |
|
\ n1 is the size of the type on the data stack |
|
\ n2 is the size of the type on the FP stack |
|
\ stack effect entries of the type start with prefix |
|
>r >r >r >r |
|
dup >r here >r s, |
|
create |
|
r> r> 2, |
|
r> r> r> , r> , swap , , ; |
|
|
|
wordlist constant types |
|
get-current |
|
types set-current |
|
|
|
s" Bool" single-type starts-with f |
|
s" Char" single-type starts-with c |
|
s" Cell" single-type starts-with n |
|
s" Cell" single-type starts-with w |
|
s" UCell" single-type starts-with u |
|
s" DCell" double-type starts-with d |
|
s" UDCell" double-type starts-with ud |
|
s" Float" float-type starts-with r |
|
s" Cell *" single-type starts-with a_ |
|
s" Char *" single-type starts-with c_ |
|
s" Float *" single-type starts-with f_ |
|
s" DFloat *" single-type starts-with df_ |
|
s" SFloat *" single-type starts-with sf_ |
|
s" Xt" single-type starts-with xt |
|
s" WID" single-type starts-with wid |
|
s" F83Name *" single-type starts-with f83name |
|
|
|
set-current |
|
|
|
: get-type ( addr1 u1 -- type-descr ) |
|
\ get the type of the name in addr1 u1 |
|
\ type-descr is a pointer to a type-descriptor |
|
0 swap ?do |
|
dup i types search-wordlist |
|
if \ ok, we have the type ( addr1 xt ) |
|
execute nip |
|
UNLOOP EXIT |
|
endif |
|
-1 s+loop |
|
\ we did not find a type, abort |
|
." unknown type prefix" cr ABORT ; |
|
|
|
: declare ( addr "name" -- ) |
: declare ( addr "name" -- ) |
\ remember that there is a stack item at addr called name |
\ remember that there is a stack item at addr called name |
create , ; |
create , ; |
|
|
|
: !default ( w addr -- ) |
|
dup @ if |
|
2drop \ leave nonzero alone |
|
else |
|
! |
|
endif ; |
|
|
|
: create-type { addr u xt1 xt2 n stack -- } ( "prefix" -- ) |
|
\ describes a type |
|
\ addr u specifies the C type name |
|
\ stack effect entries of the type start with prefix |
|
create type% %allot >r |
|
addr u save-mem r@ type-c-name 2! |
|
xt1 r@ type-fetch ! |
|
xt2 r@ type-store ! |
|
n r@ type-size ! |
|
stack r@ type-stack ! |
|
rdrop ; |
|
|
|
: type-prefix ( xt1 xt2 n stack "prefix" -- ) |
|
create-type |
|
does> ( item -- ) |
|
\ initialize item |
|
{ item typ } |
|
typ item item-type ! |
|
typ type-stack @ item item-stack !default |
|
item item-name 2@ items @ search-wordlist 0= if \ new name |
|
item item-name 2@ 2dup nextname item declare |
|
typ type-c-name 2@ type space type ." ;" cr |
|
else |
|
drop |
|
endif ; |
|
|
|
: execute-prefix ( item addr1 u1 -- ) |
|
\ execute the word ( item -- ) associated with the longest prefix |
|
\ of addr1 u1 |
|
0 swap ?do |
|
dup i prefixes search-wordlist |
|
if \ ok, we have the type ( item addr1 xt ) |
|
nip execute |
|
UNLOOP EXIT |
|
endif |
|
-1 s+loop |
|
\ we did not find a type, abort |
|
true abort" unknown prefix" ; |
|
|
: declaration ( item -- ) |
: declaration ( item -- ) |
dup item-name 2@ items @ search-wordlist |
dup item-name 2@ execute-prefix ; |
if \ already declared ( item xt ) |
|
execute @ item-type @ swap item-type ! |
|
else ( addr ) |
|
dup item-name 2@ nextname dup declare ( addr ) |
|
dup >r item-name 2@ 2dup get-type ( addr1 u type-descr ) |
|
dup r> item-type ! ( addr1 u type-descr ) |
|
type-c-name 2@ type space type ." ;" cr |
|
endif ; |
|
|
|
|
: stack-prefix ( stack "prefix" -- ) |
|
name tuck nextname create ( stack length ) 2, |
|
does> ( item -- ) |
|
2@ { item stack prefix-length } |
|
item item-name 2@ prefix-length /string item item-name 2! |
|
stack item item-stack ! |
|
item declaration ; |
|
|
: declaration-list ( addr1 addr2 -- ) |
: declaration-list ( addr1 addr2 -- ) |
swap ?do |
swap ?do |
i declaration |
i declaration |
item-descr +loop ; |
item% %size +loop ; |
|
|
: declarations ( -- ) |
: declarations ( -- ) |
wordlist dup items ! set-current |
wordlist dup items ! set-current |
Line 438 set-current
|
Line 524 set-current
|
\ the leftmost (i.e. deepest) item has offset 0 |
\ the leftmost (i.e. deepest) item has offset 0 |
\ the rightmost item has the highest offset |
\ the rightmost item has the highest offset |
|
|
: compute-offset ( n1 n2 item -- n3 n4 ) |
: compute-offset { item xt -- } |
\ n1, n3 are data-stack-offsets |
\ xt specifies in/out; update stack-in/out and set item-offset |
\ n2, n4 are the fp-stack-offsets |
item item-type @ type-size @ |
>r |
item item-stack @ xt execute dup @ >r +! |
swap dup r@ item-d-offset ! |
r> item item-offset ! ; |
r@ item-type @ type-d-size + |
|
swap dup r@ item-f-offset ! |
: compute-list ( addr1 addr2 xt -- ) |
r@ item-type @ type-f-size + |
{ xt } |
rdrop ; |
swap u+do |
|
i xt compute-offset |
|
item% %size +loop ; |
|
|
: compute-list ( addr1 addr2 -- n1 n2 ) |
: clear-stack { -- } |
\ n1, n2 are the final offsets |
dup stack-in off stack-out off ; |
0 0 2swap swap ?do |
|
i compute-offset |
|
item-descr +loop ; |
|
|
|
: compute-offsets ( -- ) |
: compute-offsets ( -- ) |
effect-in effect-in-end @ compute-list effect-in-size 2! |
data-stack clear-stack fp-stack clear-stack return-stack clear-stack |
effect-out effect-out-end @ compute-list effect-out-size 2! ; |
inst-stream clear-stack |
|
effect-in effect-in-end @ ['] stack-in compute-list |
|
effect-out effect-out-end @ ['] stack-out compute-list |
|
inst-stream stack-out @ 0<> abort" # can only be on the input side" ; |
|
|
|
: flush-a-tos { stack -- } |
|
stack stack-out @ 0<> stack stack-in @ 0= and |
|
if |
|
." IF_" stack stack-pointer 2@ 2dup type ." TOS(" |
|
2dup type ." [0] = " type ." TOS);" cr |
|
endif ; |
|
|
: flush-tos ( -- ) |
: flush-tos ( -- ) |
effect-in-size 2@ effect-out-size 2@ |
data-stack flush-a-tos |
0<> rot 0= and |
fp-stack flush-a-tos |
if |
return-stack flush-a-tos ; |
." IF_FTOS(fp[0] = FTOS);" cr |
|
endif |
: fill-a-tos { stack -- } |
0<> swap 0= and |
stack stack-out @ 0= stack stack-in @ 0<> and |
if |
if |
." IF_TOS(sp[0] = TOS);" cr |
." IF_" stack stack-pointer 2@ 2dup type ." TOS(" |
endif ; |
2dup type ." TOS = " type ." [0]);" cr |
|
endif ; |
|
|
: fill-tos ( -- ) |
: fill-tos ( -- ) |
effect-in-size 2@ effect-out-size 2@ |
\ !! inst-stream for prefetching? |
0= rot 0<> and |
fp-stack fill-a-tos |
if |
data-stack fill-a-tos |
." IF_FTOS(FTOS = fp[0]);" cr |
return-stack fill-a-tos ; |
endif |
|
0= swap 0<> and |
|
if |
|
." IF_TOS(TOS = sp[0]);" cr |
|
endif ; |
|
|
|
: fetch ( addr -- ) |
: fetch ( addr -- ) |
dup item-type @ type-fetch-handler execute ; |
dup item-type @ type-fetch @ execute ; |
|
|
: fetches ( -- ) |
: fetches ( -- ) |
effect-in-end @ effect-in ?do |
effect-in-end @ effect-in ?do |
i fetch |
i fetch |
item-descr +loop ; |
item% %size +loop ; |
|
|
|
: stack-pointer-update { stack -- } |
|
\ stack grow downwards |
|
stack stack-in @ stack stack-out @ - |
|
?dup-if \ this check is not necessary, gcc would do this for us |
|
stack stack-pointer 2@ type ." += " 0 .r ." ;" cr |
|
endif ; |
|
|
|
: inst-pointer-update ( -- ) |
|
inst-stream stack-in @ ?dup-if |
|
." INC_IP(" 0 .r ." );" cr |
|
endif ; |
|
|
: stack-pointer-updates ( -- ) |
: stack-pointer-updates ( -- ) |
\ we do not check if an update is a noop; gcc does this for us |
inst-pointer-update |
effect-in-size 2@ |
data-stack stack-pointer-update |
effect-out-size 2@ |
fp-stack stack-pointer-update |
rot swap - ( d-in d-out f-diff ) |
return-stack stack-pointer-update ; |
rot rot - ( f-diff d-diff ) |
|
?dup IF ." sp += " 0 .r ." ;" cr THEN |
|
?dup IF ." fp += " 0 .r ." ;" cr THEN ; |
|
|
|
: store ( item -- ) |
: store ( item -- ) |
\ f is true if the item should be stored |
\ f is true if the item should be stored |
\ f is false if the store is probably not necessary |
\ f is false if the store is probably not necessary |
dup item-type @ type-store-handler execute ; |
dup item-type @ type-store @ execute ; |
|
|
: stores ( -- ) |
: stores ( -- ) |
effect-out-end @ effect-out ?do |
effect-out-end @ effect-out ?do |
i store |
i store |
item-descr +loop ; |
item% %size +loop ; |
|
|
|
: output-c-tail ( -- ) |
|
\ the final part of the generated C code |
|
." NEXT_P1;" cr |
|
stores |
|
fill-tos |
|
." NEXT_P2;" cr ; |
|
|
|
: type-c ( c-addr u -- ) |
|
\ like TYPE, but replaces "TAIL;" with tail code |
|
begin ( c-addr1 u1 ) |
|
2dup s" TAIL;" search |
|
while ( c-addr1 u1 c-addr3 u3 ) |
|
2dup 2>r drop nip over - type |
|
output-c-tail |
|
2r> 5 /string |
|
\ !! resync #line missing |
|
repeat |
|
2drop type ; |
|
|
: output-c ( -- ) |
: output-c ( -- ) |
." I_" c-name 2@ type ." : /* " forth-name 2@ type ." ( " stack-string 2@ type ." ) */" cr |
." I_" c-name 2@ type ." : /* " forth-name 2@ type ." ( " stack-string 2@ type ." ) */" cr |
." /* " doc 2@ type ." */" cr |
." /* " doc 2@ type ." */" cr |
|
." NAME(" [char] " emit forth-name 2@ type [char] " emit ." )" cr \ debugging |
." {" cr |
." {" cr |
." DEF_CA" cr |
." DEF_CA" cr |
declarations |
declarations |
compute-offsets \ for everything else |
compute-offsets \ for everything else |
|
." NEXT_P0;" cr |
flush-tos |
flush-tos |
fetches |
fetches |
stack-pointer-updates cr |
stack-pointer-updates |
." NAME(" [char] " emit forth-name 2@ type [char] " emit ." )" cr \ debugging |
|
." {" cr |
." {" cr |
c-code 2@ type |
." #line " c-line @ . [char] " emit c-filename 2@ type [char] " emit cr |
|
c-code 2@ type-c |
." }" cr |
." }" cr |
." NEXT_P1;" cr |
output-c-tail |
stores |
|
fill-tos |
|
." NEXT1_P2;" cr |
|
." }" cr |
." }" cr |
cr |
cr |
; |
; |
|
|
: output-label ( -- ) |
: print-type-prefix ( type -- ) |
." &&I_" c-name 2@ type ." ," cr ; |
body> >head .name ; |
|
|
: output-alias ( -- ) |
: disasm-arg { item -- } |
primitive-number @ . ." alias " forth-name 2@ type cr |
item item-stack @ inst-stream = if |
-1 primitive-number +! ; |
." printarg_" item item-type @ print-type-prefix |
|
." (ip[" item item-offset @ 1+ 0 .r ." ]);" cr |
|
endif ; |
|
|
: process-file ( addr u xt -- ) |
: disasm-args ( -- ) |
>r r/o open-file |
effect-in-end @ effect-in ?do |
if |
i disasm-arg |
." cannot open file" cr abort |
item% %size +loop ; |
endif |
|
warnings @ if |
|
." ------------ CUT HERE -------------" cr endif |
|
r> primfilter ; |
|
|
|
|
: output-disasm ( -- ) |
|
\ generate code for disassembling VM instructions |
|
." if (ip[0] == prim[" function-number @ 0 .r ." ]) {" cr |
|
." fputs(" [char] " emit forth-name 2@ type [char] " emit ." ,stdout);" cr |
|
." /* " declarations ." */" cr |
|
compute-offsets |
|
disasm-args |
|
." ip += " inst-stream stack-in @ 1+ 0 .r ." ;" cr |
|
." } else " |
|
1 function-number +! ; |
|
|
|
: stack-used? { stack -- f } |
|
stack stack-in @ stack stack-out @ or 0<> ; |
|
|
|
: output-funclabel ( -- ) |
|
1 function-number +! |
|
." &I_" c-name 2@ type ." ," cr ; |
|
|
|
: output-forthname ( -- ) |
|
1 function-number +! |
|
'" emit forth-name 2@ type '" emit ." ," cr ; |
|
|
|
: output-c-func ( -- ) |
|
\ used for word libraries |
|
1 function-number +! |
|
." Cell * I_" c-name 2@ type ." (Cell *SP, Cell **FP) /* " forth-name 2@ type |
|
." ( " stack-string 2@ type ." ) */" cr |
|
." /* " doc 2@ type ." */" cr |
|
." NAME(" [char] " emit forth-name 2@ type [char] " emit ." )" cr |
|
\ debugging |
|
." {" cr |
|
declarations |
|
compute-offsets \ for everything else |
|
inst-stream stack-used? IF ." Cell *ip=IP;" cr THEN |
|
data-stack stack-used? IF ." Cell *sp=SP;" cr THEN |
|
fp-stack stack-used? IF ." Cell *fp=*FP;" cr THEN |
|
return-stack stack-used? IF ." Cell *rp=*RP;" cr THEN |
|
flush-tos |
|
fetches |
|
stack-pointer-updates |
|
fp-stack stack-used? IF ." *FP=fp;" cr THEN |
|
." {" cr |
|
." #line " c-line @ . [char] " emit c-filename 2@ type [char] " emit cr |
|
c-code 2@ type |
|
." }" cr |
|
stores |
|
fill-tos |
|
." return (sp);" cr |
|
." }" cr |
|
cr ; |
|
|
|
: output-label ( -- ) |
|
." (Label)&&I_" c-name 2@ type ." ," cr |
|
-1 primitive-number +! ; |
|
|
|
: output-alias ( -- ) |
|
( primitive-number @ . ." alias " ) ." Primitive " forth-name 2@ type cr |
|
-1 primitive-number +! ; |
|
|
|
: output-forth ( -- ) |
|
forth-code @ 0= |
|
IF \ output-alias |
|
\ this is bad for ec: an alias is compiled if tho word does not exist! |
|
\ JAW |
|
ELSE ." : " forth-name 2@ type ." ( " |
|
stack-string 2@ type ." )" cr |
|
forth-code 2@ type cr |
|
-1 primitive-number +! |
|
THEN ; |
|
|
|
: output-tag-file ( -- ) |
|
name-filename 2@ last-name-filename 2@ compare if |
|
name-filename 2@ last-name-filename 2! |
|
#ff emit cr |
|
name-filename 2@ type |
|
." ,0" cr |
|
endif ; |
|
|
|
: output-tag ( -- ) |
|
output-tag-file |
|
forth-name 2@ 1+ type |
|
127 emit |
|
space forth-name 2@ type space |
|
1 emit |
|
name-line @ 0 .r |
|
." ,0" cr ; |
|
|
|
[IFDEF] documentation |
|
: register-doc ( -- ) |
|
get-current documentation set-current |
|
forth-name 2@ nextname create |
|
forth-name 2@ 2, |
|
stack-string 2@ condition-stack-effect 2, |
|
wordset 2@ 2, |
|
c-name 2@ condition-pronounciation 2, |
|
doc 2@ 2, |
|
set-current ; |
|
[THEN] |
|
|
|
: process-file ( addr u xt -- ) |
|
>r |
|
2dup filename 2! |
|
0 function-number ! |
|
r/o open-file abort" cannot open file" |
|
warnings @ if |
|
." ------------ CUT HERE -------------" cr endif |
|
r> primfilter ; |
|
|
|
: process ( xt -- ) |
|
bl word count rot |
|
process-file ; |