version 1.81, 1999/08/29 21:44:45
|
version 1.96, 2001/03/18 22:20:26
|
Line 1
|
Line 1
|
\ CROSS.FS The Cross-Compiler 06oct92py |
\ CROSS.FS The Cross-Compiler 06oct92py |
\ Idea and implementation: Bernd Paysan (py) |
\ Idea and implementation: Bernd Paysan (py) |
|
|
\ Copyright (C) 1995,1996,1997,1998,1999 Free Software Foundation, Inc. |
\ Copyright (C) 1995,1996,1997,1998,1999,2000 Free Software Foundation, Inc. |
|
|
\ This file is part of Gforth. |
\ This file is part of Gforth. |
|
|
Line 17
|
Line 17
|
|
|
\ You should have received a copy of the GNU General Public License |
\ You should have received a copy of the GNU General Public License |
\ along with this program; if not, write to the Free Software |
\ along with this program; if not, write to the Free Software |
\ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
\ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA. |
|
|
0 |
0 |
[IF] |
[IF] |
Line 474 Create tfile 0 c, 255 chars allot
|
Line 474 Create tfile 0 c, 255 chars allot
|
THEN ; |
THEN ; |
|
|
: compact.. ( adr len -- adr2 len2 ) |
: compact.. ( adr len -- adr2 len2 ) |
\ deletes phrases like "xy/.." out of our directory name 2dec97jaw |
\ deletes phrases like "xy/.." out of our directory name 2dec97jaw |
over >r -1 >r |
over swap |
BEGIN dup WHILE |
BEGIN dup WHILE |
over c@ pathsep? |
dup >r '/ scan 2dup 4 min s" /../" compare 0= |
IF r@ -1 = |
IF |
IF r> drop dup >r |
dup r> - >r 4 /string over r> + 4 - |
ELSE 2dup 1 /string |
swap 2dup + >r move dup r> over - |
3 min s" ../" compare |
ELSE |
0= |
rdrop dup 1 min /string |
IF r@ over - ( diff ) |
THEN |
2 pick swap - ( dest-adr ) |
REPEAT drop over - ; |
>r 3 /string r> swap 2dup >r >r |
|
move r> r> |
|
ELSE r> drop dup >r |
|
THEN |
|
THEN |
|
THEN |
|
1 /string |
|
REPEAT |
|
r> drop |
|
drop r> tuck - ; |
|
|
|
: reworkdir ( -- ) |
: reworkdir ( -- ) |
remove~+ |
remove~+ |
Line 666 hex
|
Line 656 hex
|
4713 Constant <imm> 4714 Constant <do:> |
4713 Constant <imm> 4714 Constant <do:> |
4715 Constant <skip> |
4715 Constant <skip> |
|
|
\ iForth makes only immediate directly after create |
\ Compiler States |
\ make atonce trick! ? |
|
|
|
Variable atonce atonce off |
Variable comp-state |
|
0 Constant interpreting |
|
1 Constant compiling |
|
2 Constant resolving |
|
3 Constant assembling |
|
|
: NoExec true ABORT" CROSS: Don't execute ghost, or immediate target word" ; |
Defer lit, ( n -- ) |
|
Defer alit, ( n -- ) |
|
|
|
Defer branch, ( target-addr -- ) \ compiles a branch |
|
Defer ?branch, ( target-addr -- ) \ compiles a ?branch |
|
Defer branchmark, ( -- branch-addr ) \ reserves room for a branch |
|
Defer ?branchmark, ( -- branch-addr ) \ reserves room for a ?branch |
|
Defer ?domark, ( -- branch-addr ) \ reserves room for a ?do branch |
|
Defer branchto, ( -- ) \ actual program position is target of a branch (do e.g. alignment) |
|
Defer branchtoresolve, ( branch-addr -- ) \ resolves a forward reference from branchmark |
|
Defer branchfrom, ( -- ) \ ?! |
|
Defer branchtomark, ( -- target-addr ) \ marks a branch destination |
|
|
|
Defer colon, ( tcfa -- ) \ compiles call to tcfa at current position |
|
Defer prim, ( tcfa -- ) \ compiles a primitive invocation |
|
\ at current position |
|
Defer colonmark, ( -- addr ) \ marks a colon call |
|
Defer colon-resolve ( tcfa addr -- ) |
|
|
|
Defer addr-resolve ( target-addr addr -- ) |
|
Defer doer-resolve ( ghost res-pnt target-addr addr -- ghost res-pnt ) |
|
|
|
Defer do, ( -- do-token ) |
|
Defer ?do, ( -- ?do-token ) |
|
Defer for, ( -- for-token ) |
|
Defer loop, ( do-token / ?do-token -- ) |
|
Defer +loop, ( do-token / ?do-token -- ) |
|
Defer next, ( for-token ) |
|
|
|
[IFUNDEF] ca>native |
|
defer ca>native |
|
[THEN] |
|
|
: GhostHeader <fwd> , 0 , ['] NoExec , ; |
\ ghost structure |
|
|
: >magic ; \ type of ghost |
: >magic ; \ type of ghost |
: >link cell+ ; \ pointer where ghost is in target, or if unresolved |
: >link cell+ ; \ pointer where ghost is in target, or if unresolved |
\ points to the where we have to resolve (linked-list) |
\ points to the where we have to resolve (linked-list) |
: >exec cell+ cell+ ; \ execution symantics (while target compiling) of ghost |
: >exec cell+ cell+ ; \ execution symantics (while target compiling) of ghost |
: >end 3 cells + ; \ room for additional tags |
: >comp 3 cells + ; \ compilation semantics |
|
: >end 4 cells + ; \ room for additional tags |
\ for builder (create, variable...) words the |
\ for builder (create, variable...) words the |
\ execution symantics of words built are placed here |
\ execution symantics of words built are placed here |
|
|
|
\ resolve structure |
|
|
|
: >next ; \ link to next field |
|
: >tag cell+ ; \ indecates type of reference: 0: call, 1: address, 2: doer |
|
: >taddr cell+ cell+ ; |
|
: >ghost 3 cells + ; |
|
: >file 4 cells + ; |
|
: >line 5 cells + ; |
|
|
|
\ refer variables |
|
|
Variable executed-ghost \ last executed ghost, needed in tcreate and gdoes> |
Variable executed-ghost \ last executed ghost, needed in tcreate and gdoes> |
Variable last-ghost \ last ghost that is created |
Variable last-ghost \ last ghost that is created |
Variable last-header-ghost \ last ghost definitions with header |
Variable last-header-ghost \ last ghost definitions with header |
|
|
|
: (refered) ( ghost addr tag -- ) |
|
\G creates a reference to ghost at address taddr |
|
rot >r here r@ >link @ , r> >link ! |
|
( taddr tag ) , |
|
( taddr ) , |
|
last-header-ghost @ , |
|
loadfile , |
|
sourceline# , |
|
; |
|
|
|
\ iForth makes only immediate directly after create |
|
\ make atonce trick! ? |
|
|
|
Variable atonce atonce off |
|
|
|
: NoExec true ABORT" CROSS: Don't execute ghost, or immediate target word" ; |
|
|
|
: is-forward ( ghost -- ) |
|
colonmark, 0 (refered) ; \ compile space for call |
|
|
|
: GhostHeader <fwd> , 0 , ['] NoExec , ['] is-forward , ; |
|
|
: Make-Ghost ( "name" -- ghost ) |
: Make-Ghost ( "name" -- ghost ) |
>in @ GhostName swap >in ! |
>in @ GhostName swap >in ! |
<T Create atonce @ IF immediate atonce off THEN |
<T Create atonce @ IF immediate atonce off THEN |
Line 750 ghost (next)
|
Line 808 ghost (next)
|
ghost unloop ghost ;S 2drop |
ghost unloop ghost ;S 2drop |
ghost lit ghost (compile) ghost ! 2drop drop |
ghost lit ghost (compile) ghost ! 2drop drop |
ghost (does>) ghost noop 2drop |
ghost (does>) ghost noop 2drop |
ghost (.") ghost (S") ghost (ABORT") 2drop drop |
ghost (.") ghost (S") ghost (ABORT") 2drop drop ( " ) |
ghost ' drop |
ghost ' drop |
ghost :docol ghost :doesjump ghost :dodoes 2drop drop |
ghost :docol ghost :doesjump ghost :dodoes 2drop drop |
ghost :dovar drop |
ghost :dovar ghost :dodefer ghost :dofield 2drop drop |
ghost over ghost = ghost drop 2drop drop |
ghost over ghost = ghost drop 2drop drop |
ghost - drop |
ghost call ghost useraddr ghost execute 2drop drop |
|
ghost + ghost - ghost @ 2drop drop |
ghost 2drop drop |
ghost 2drop drop |
ghost 2dup drop |
ghost 2dup drop |
|
|
Line 787 VARIABLE env-current \ save information
|
Line 846 VARIABLE env-current \ save information
|
|
|
>ENVIRON get-order get-current swap 1+ set-order |
>ENVIRON get-order get-current swap 1+ set-order |
true SetValue compiler |
true SetValue compiler |
true SetValue cross |
true SetValue cross |
true SetValue standard-threading |
true SetValue standard-threading |
>TARGET previous |
>TARGET previous |
|
|
Line 812 false DefaultValue dcomps
|
Line 871 false DefaultValue dcomps
|
false DefaultValue hash |
false DefaultValue hash |
false DefaultValue xconds |
false DefaultValue xconds |
false DefaultValue header |
false DefaultValue header |
|
false DefaultValue backtrace |
|
false DefaultValue new-input |
[THEN] |
[THEN] |
|
|
true DefaultValue interpreter |
true DefaultValue interpreter |
Line 1180 CREATE Bittable 80 c, 40 c, 20 c, 10 c,
|
Line 1241 CREATE Bittable 80 c, 40 c, 20 c, 10 c,
|
: +bit ( addr n -- ) >bit over c@ or swap c! ; |
: +bit ( addr n -- ) >bit over c@ or swap c! ; |
: -bit ( addr n -- ) >bit invert over c@ and swap c! ; |
: -bit ( addr n -- ) >bit invert over c@ and swap c! ; |
|
|
: (relon) ( taddr -- ) bit$ @ swap cell/ +bit ; |
: (relon) ( taddr -- ) |
: (reloff) ( taddr -- ) bit$ @ swap cell/ -bit ; |
[ [IFDEF] fd-relocation-table ] |
|
s" +" fd-relocation-table write-file throw |
|
dup s>d <# #s #> fd-relocation-table write-line throw |
|
[ [THEN] ] |
|
bit$ @ swap cell/ +bit ; |
|
|
|
: (reloff) ( taddr -- ) |
|
[ [IFDEF] fd-relocation-table ] |
|
s" -" fd-relocation-table write-file throw |
|
dup s>d <# #s #> fd-relocation-table write-line throw |
|
[ [THEN] ] |
|
bit$ @ swap cell/ -bit ; |
|
|
: (>image) ( taddr -- absaddr ) image @ + ; |
: (>image) ( taddr -- absaddr ) image @ + ; |
|
|
Line 1222 T has? relocate H
|
Line 1294 T has? relocate H
|
: c@ ( taddr -- char ) >image Sc@ ; |
: c@ ( taddr -- char ) >image Sc@ ; |
: c! ( char taddr -- ) >image Sc! ; |
: c! ( char taddr -- ) >image Sc! ; |
: 2@ ( taddr -- x1 x2 ) T dup cell+ @ swap @ H ; |
: 2@ ( taddr -- x1 x2 ) T dup cell+ @ swap @ H ; |
: 2! ( x1 x2 taddr -- ) T swap over ! cell+ ! H ; |
: 2! ( x1 x2 taddr -- ) T tuck ! cell+ ! H ; |
|
|
\ Target compilation primitives 06oct92py |
\ Target compilation primitives 06oct92py |
\ included A! 16may93jaw |
\ included A! 16may93jaw |
Line 1265 previous
|
Line 1337 previous
|
|
|
\ \ -------------------- Compiler Plug Ins 01aug97jaw |
\ \ -------------------- Compiler Plug Ins 01aug97jaw |
|
|
\ Compiler States |
|
|
|
Variable comp-state |
|
0 Constant interpreting |
|
1 Constant compiling |
|
2 Constant resolving |
|
3 Constant assembling |
|
|
|
Defer lit, ( n -- ) |
|
Defer alit, ( n -- ) |
|
|
|
Defer branch, ( target-addr -- ) \ compiles a branch |
|
Defer ?branch, ( target-addr -- ) \ compiles a ?branch |
|
Defer branchmark, ( -- branch-addr ) \ reserves room for a branch |
|
Defer ?branchmark, ( -- branch-addr ) \ reserves room for a ?branch |
|
Defer ?domark, ( -- branch-addr ) \ reserves room for a ?do branch |
|
Defer branchto, ( -- ) \ actual program position is target of a branch (do e.g. alignment) |
|
Defer branchtoresolve, ( branch-addr -- ) \ resolves a forward reference from branchmark |
|
Defer branchfrom, ( -- ) \ ?! |
|
Defer branchtomark, ( -- target-addr ) \ marks a branch destination |
|
|
|
Defer colon, ( tcfa -- ) \ compiles call to tcfa at current position |
|
Defer colonmark, ( -- addr ) \ marks a colon call |
|
Defer colon-resolve ( tcfa addr -- ) |
|
|
|
Defer addr-resolve ( target-addr addr -- ) |
|
Defer doer-resolve ( ghost res-pnt target-addr addr -- ghost res-pnt ) |
|
|
|
Defer do, ( -- do-token ) |
|
Defer ?do, ( -- ?do-token ) |
|
Defer for, ( -- for-token ) |
|
Defer loop, ( do-token / ?do-token -- ) |
|
Defer +loop, ( do-token / ?do-token -- ) |
|
Defer next, ( for-token ) |
|
|
|
[IFUNDEF] ca>native |
|
defer ca>native |
|
[THEN] |
|
|
|
>TARGET |
>TARGET |
DEFER >body \ we need the system >body |
DEFER >body \ we need the system >body |
\ and the target >body |
\ and the target >body |
Line 1319 DEFER dodoes,
|
Line 1352 DEFER dodoes,
|
DEFER ]comp \ starts compilation |
DEFER ]comp \ starts compilation |
DEFER comp[ \ ends compilation |
DEFER comp[ \ ends compilation |
|
|
: (cc) T a, H ; ' (cc) IS colon, |
: (prim) T a, H ; ' (prim) IS prim, |
|
|
: (cr) >tempdp ]comp colon, comp[ tempdp> ; ' (cr) IS colon-resolve |
: (cr) >tempdp ]comp prim, comp[ tempdp> ; ' (cr) IS colon-resolve |
: (ar) T ! H ; ' (ar) IS addr-resolve |
: (ar) T ! H ; ' (ar) IS addr-resolve |
: (dr) ( ghost res-pnt target-addr addr ) |
: (dr) ( ghost res-pnt target-addr addr ) |
>tempdp drop over |
>tempdp drop over |
Line 1333 DEFER comp[ \ ends compilation
|
Line 1366 DEFER comp[ \ ends compilation
|
|
|
: (cm) ( -- addr ) |
: (cm) ( -- addr ) |
T here align H |
T here align H |
-1 colon, ; ' (cm) IS colonmark, |
-1 prim, ; ' (cm) IS colonmark, |
|
|
>TARGET |
>TARGET |
: compile, colon, ; |
: compile, prim, ; |
>CROSS |
>CROSS |
|
|
\ resolve structure |
|
|
|
: >next ; \ link to next field |
|
: >tag cell+ ; \ indecates type of reference: 0: call, 1: address, 2: doer |
|
: >taddr cell+ cell+ ; |
|
: >ghost 3 cells + ; |
|
: >file 4 cells + ; |
|
: >line 5 cells + ; |
|
|
|
: (refered) ( ghost addr tag -- ) |
|
\G creates a reference to ghost at address taddr |
|
rot >r here r@ >link @ , r> >link ! |
|
( taddr tag ) , |
|
( taddr ) , |
|
last-header-ghost @ , |
|
loadfile , |
|
sourceline# , |
|
; |
|
|
|
: refered ( ghost tag -- ) |
: refered ( ghost tag -- ) |
\G creates a resolve structure |
\G creates a resolve structure |
T here aligned H swap (refered) |
T here aligned H swap (refered) |
Line 1427 Exists-Warnings on
|
Line 1441 Exists-Warnings on
|
ELSE true abort" CROSS: Ghostnames inconsistent " |
ELSE true abort" CROSS: Ghostnames inconsistent " |
THEN ; |
THEN ; |
|
|
|
: colon-resolved ( ghost -- ) |
|
>link @ colon, ; \ compile-call |
|
: prim-resolved ( ghost -- ) |
|
>link @ prim, ; |
|
|
: resolve ( ghost tcfa -- ) |
: resolve ( ghost tcfa -- ) |
\G resolve referencies to ghost with tcfa |
\G resolve referencies to ghost with tcfa |
\ is ghost resolved?, second resolve means another definition with the |
\ is ghost resolved?, second resolve means another definition with the |
Line 1436 Exists-Warnings on
|
Line 1455 Exists-Warnings on
|
swap >r r@ >link @ swap \ ( list tcfa R: ghost ) |
swap >r r@ >link @ swap \ ( list tcfa R: ghost ) |
\ mark ghost as resolved |
\ mark ghost as resolved |
dup r@ >link ! <res> r@ >magic ! |
dup r@ >link ! <res> r@ >magic ! |
|
r@ >comp @ ['] is-forward = IF |
|
['] prim-resolved r@ >comp ! THEN |
\ loop through forward referencies |
\ loop through forward referencies |
r> -rot |
r> -rot |
comp-state @ >r Resolving comp-state ! |
comp-state @ >r Resolving comp-state ! |
Line 1447 Exists-Warnings on
|
Line 1468 Exists-Warnings on
|
|
|
\ gexecute ghost, 01nov92py |
\ gexecute ghost, 01nov92py |
|
|
: is-forward ( ghost -- ) |
|
colonmark, 0 (refered) ; \ compile space for call |
|
|
|
: is-resolved ( ghost -- ) |
|
>link @ colon, ; \ compile-call |
|
|
|
: gexecute ( ghost -- ) |
: gexecute ( ghost -- ) |
dup @ <fwd> = IF is-forward ELSE is-resolved THEN ; |
dup >comp @ execute ; |
|
|
: addr, ( ghost -- ) |
: addr, ( ghost -- ) |
dup @ <fwd> = IF 1 refered 0 T a, H ELSE >link @ T a, H THEN ; |
dup forward? IF 1 refered 0 T a, H ELSE >link @ T a, H THEN ; |
|
|
\ !! : ghost, ghost gexecute ; |
\ !! : ghost, ghost gexecute ; |
|
|
Line 1514 variable ResolveFlag
|
Line 1529 variable ResolveFlag
|
>CROSS |
>CROSS |
\ Header states 12dec92py |
\ Header states 12dec92py |
|
|
: flag! ( 8b -- ) tlast @ dup >r T c@ xor r> c! H ; |
bigendian [IF] 0 [ELSE] tcell 1- [THEN] Constant flag+ |
|
: flag! ( w -- ) tlast @ flag+ + dup >r T c@ xor r> c! H ; |
|
|
VARIABLE ^imm |
VARIABLE ^imm |
|
|
|
\ !! should be target wordsize specific |
|
$80 constant alias-mask |
|
$40 constant immediate-mask |
|
$20 constant restrict-mask |
|
|
>TARGET |
>TARGET |
: immediate 40 flag! |
: immediate immediate-mask flag! |
^imm @ @ dup <imm> = IF drop EXIT THEN |
^imm @ @ dup <imm> = IF drop EXIT THEN |
<res> <> ABORT" CROSS: Cannot immediate a unresolved word" |
<res> <> ABORT" CROSS: Cannot immediate a unresolved word" |
<imm> ^imm @ ! ; |
<imm> ^imm @ ! ; |
: restrict 20 flag! ; |
: restrict restrict-mask flag! ; |
|
|
: isdoer |
: isdoer |
\G define a forth word as doer, this makes obviously only sence on |
\G define a forth word as doer, this makes obviously only sence on |
Line 1535 VARIABLE ^imm
|
Line 1556 VARIABLE ^imm
|
|
|
>TARGET |
>TARGET |
: string, ( addr count -- ) |
: string, ( addr count -- ) |
dup T c, H bounds ?DO I c@ T c, H LOOP ; |
dup T c, H bounds ?DO I c@ T c, H LOOP ; |
: name, ( "name" -- ) bl word count T string, cfalign H ; |
: lstring, ( addr count -- ) |
|
dup T , H bounds ?DO I c@ T c, H LOOP ; |
|
: name, ( "name" -- ) bl word count T lstring, cfalign H ; |
: view, ( -- ) ( dummy ) ; |
: view, ( -- ) ( dummy ) ; |
>CROSS |
>CROSS |
|
|
Line 1651 NoHeaderFlag off
|
Line 1674 NoHeaderFlag off
|
base @ >r hex |
base @ >r hex |
0 swap <# 0 ?DO # LOOP #> type |
0 swap <# 0 ?DO # LOOP #> type |
r> base ! ; |
r> base ! ; |
: .sym |
|
|
: .sym ( adr len -- ) |
|
\G escapes / and \ to produce sed output |
bounds |
bounds |
DO I c@ dup |
DO I c@ dup |
CASE [char] / OF drop ." \/" ENDOF |
CASE [char] / OF drop ." \/" ENDOF |
Line 1674 NoHeaderFlag off
|
Line 1699 NoHeaderFlag off
|
>in @ T name, H >in ! |
>in @ T name, H >in ! |
THEN |
THEN |
T cfalign here H tlastcfa ! |
T cfalign here H tlastcfa ! |
\ Symbol table |
\ Old Symbol table sed-script |
\ >in @ cr ." sym:s/CFA=" there 4 0.r ." /" bl word count .sym ." /g" cr >in ! |
\ >in @ cr ." sym:s/CFA=" there 4 0.r ." /" bl word count .sym ." /g" cr >in ! |
ghost |
ghost |
|
\ output symbol table to extra file |
|
[ [IFDEF] fd-symbol-table ] |
|
base @ hex there s>d <# 8 0 DO # LOOP #> fd-symbol-table write-file throw base ! |
|
s" :" fd-symbol-table write-file throw |
|
dup >ghostname fd-symbol-table write-line throw |
|
[ [THEN] ] |
dup Last-Header-Ghost ! |
dup Last-Header-Ghost ! |
dup >magic ^imm ! \ a pointer for immediate |
dup >magic ^imm ! \ a pointer for immediate |
Already @ |
Already @ |
IF dup >end tdoes ! |
IF dup >end tdoes ! |
ELSE 0 tdoes ! |
ELSE 0 tdoes ! |
THEN |
THEN |
80 flag! |
alias-mask flag! |
cross-doc-entry cross-tag-entry ; |
cross-doc-entry cross-tag-entry ; |
|
|
VARIABLE ;Resolve 1 cells allot |
VARIABLE ;Resolve 1 cells allot |
Line 1700 VARIABLE ;Resolve 1 cells allot
|
Line 1731 VARIABLE ;Resolve 1 cells allot
|
IF |
IF |
.sourcepos ." needs prim: " >in @ bl word count type >in ! cr |
.sourcepos ." needs prim: " >in @ bl word count type >in ! cr |
THEN |
THEN |
(THeader over resolve T A, H 80 flag! ; |
(THeader over resolve T A, H alias-mask flag! ; |
: Alias: ( cfa -- ) \ name |
: Alias: ( cfa -- ) \ name |
>in @ skip? IF 2drop EXIT THEN >in ! |
>in @ skip? IF 2drop EXIT THEN >in ! |
dup 0< s" prims" T $has? H 0= and |
dup 0< s" prims" T $has? H 0= and |
Line 1746 Comment ( Comment \
|
Line 1777 Comment ( Comment \
|
ELSE postpone literal postpone gexecute THEN ; |
ELSE postpone literal postpone gexecute THEN ; |
immediate |
immediate |
|
|
|
T has? peephole H [IF] |
|
: (cc) compile call T >body a, H ; ' (cc) IS colon, |
|
[ELSE] |
|
' (prim) IS colon, |
|
[THEN] |
|
|
: [G'] |
: [G'] |
\G ticks a ghost and returns its address |
\G ticks a ghost and returns its address |
bl word gfind 0= ABORT" CROSS: Ghost don't exists" |
bl word gfind 0= ABORT" CROSS: Ghost don't exists" |
Line 1779 Cond: ['] T ' H alit, ;Cond
|
Line 1816 Cond: ['] T ' H alit, ;Cond
|
|
|
: (>body) ( cfa -- pfa ) xt>body + ; ' (>body) T IS >body H |
: (>body) ( cfa -- pfa ) xt>body + ; ' (>body) T IS >body H |
|
|
: (doer,) ( ghost -- ) ]comp gexecute comp[ 1 fillcfa ; ' (doer,) IS doer, |
: (doer,) ( ghost -- ) ]comp addr, comp[ 1 fillcfa ; ' (doer,) IS doer, |
|
|
: (docol,) ( -- ) [G'] :docol doer, ; ' (docol,) IS docol, |
: (docol,) ( -- ) [G'] :docol doer, ; ' (docol,) IS docol, |
|
|
Line 1797 Cond: ['] T ' H alit, ;Cond
|
Line 1834 Cond: ['] T ' H alit, ;Cond
|
: (lit,) ( n -- ) compile lit T , H ; ' (lit,) IS lit, |
: (lit,) ( n -- ) compile lit T , H ; ' (lit,) IS lit, |
|
|
\ if we dont produce relocatable code alit, defaults to lit, jaw |
\ if we dont produce relocatable code alit, defaults to lit, jaw |
has? relocate |
\ this is just for convenience, so we don't have to define alit, |
|
\ seperately for embedded systems.... |
|
T has? relocate H |
[IF] |
[IF] |
: (alit,) ( n -- ) compile lit T a, H ; ' (alit,) IS alit, |
: (alit,) ( n -- ) compile lit T a, H ; ' (alit,) IS alit, |
[ELSE] |
[ELSE] |
Line 1847 Cond: [Char] ( "<char>" -- ) restrict
|
Line 1886 Cond: [Char] ( "<char>" -- ) restrict
|
\ some special literals 27jan97jaw |
\ some special literals 27jan97jaw |
|
|
\ !! Known Bug: Special Literals and plug-ins work only correct |
\ !! Known Bug: Special Literals and plug-ins work only correct |
\ on 16 and 32 Bit Targets and 32 Bit Hosts! |
\ on targets with char = 8 bit |
|
|
Cond: MAXU |
Cond: MAXU |
restrict? |
restrict? |
tcell 1 cells u> |
compile lit tcell 0 ?DO FF T c, H LOOP |
IF compile lit tcell 0 ?DO FF T c, H LOOP |
|
ELSE ffffffff lit, THEN |
|
;Cond |
;Cond |
|
|
Cond: MINI |
Cond: MINI |
restrict? |
restrict? |
tcell 1 cells u> |
compile lit bigendian |
IF compile lit bigendian |
IF 80 T c, H tcell 1 ?DO 0 T c, H LOOP |
IF 80 T c, H tcell 1 ?DO 0 T c, H LOOP |
ELSE tcell 1 ?DO 0 T c, H LOOP 80 T c, H |
ELSE tcell 1 ?DO 0 T c, H LOOP 80 T c, H |
THEN |
THEN |
|
ELSE tcell 2 = IF 8000 ELSE 80000000 THEN lit, THEN |
|
;Cond |
;Cond |
|
|
Cond: MAXI |
Cond: MAXI |
restrict? |
restrict? |
tcell 1 cells u> |
compile lit bigendian |
IF compile lit bigendian |
IF 7F T c, H tcell 1 ?DO FF T c, H LOOP |
IF 7F T c, H tcell 1 ?DO FF T c, H LOOP |
ELSE tcell 1 ?DO FF T c, H LOOP 7F T c, H |
ELSE tcell 1 ?DO FF T c, H LOOP 7F T c, H |
THEN |
THEN |
|
ELSE tcell 2 = IF 7fff ELSE 7fffffff THEN lit, THEN |
|
;Cond |
;Cond |
|
|
>CROSS |
>CROSS |
Line 1946 Cond: ; ( -- ) restrict?
|
Line 1979 Cond: ; ( -- ) restrict?
|
comp[ |
comp[ |
state off |
state off |
;Resolve @ |
;Resolve @ |
IF ;Resolve @ ;Resolve cell+ @ resolve THEN |
IF ;Resolve @ ;Resolve cell+ @ resolve |
|
['] colon-resolved ;Resolve @ >comp ! THEN |
Interpreting comp-state ! |
Interpreting comp-state ! |
;Cond |
;Cond |
Cond: [ restrict? state off Interpreting comp-state ! ;Cond |
Cond: [ restrict? state off Interpreting comp-state ! ;Cond |
Line 1964 Create GhostDummy ghostheader
|
Line 1998 Create GhostDummy ghostheader
|
GhostDummy >link ! GhostDummy |
GhostDummy >link ! GhostDummy |
tlastcfa @ >tempdp dodoes, tempdp> ; |
tlastcfa @ >tempdp dodoes, tempdp> ; |
|
|
|
: g>body ( ghost -- body ) |
|
>link @ T >body H ; |
|
: does-resolved ( ghost -- ) |
|
dup g>body alit, >end @ g>body colon, ; |
|
|
>TARGET |
>TARGET |
Cond: DOES> restrict? |
Cond: DOES> restrict? |
compile (does>) doeshandler, |
compile (does>) doeshandler, |
\ resolve words made by builders |
\ resolve words made by builders |
tdoes @ ?dup IF @ T here H resolve THEN |
tdoes @ ?dup IF @ dup T here H resolve |
|
['] prim-resolved swap >comp ! THEN |
;Cond |
;Cond |
: DOES> switchrom doeshandler, T here H !does depth T ] H ; |
: DOES> switchrom doeshandler, T here H !does depth T ] H ; |
|
|
Line 1977 Cond: DOES> restrict?
|
Line 2017 Cond: DOES> restrict?
|
|
|
\ Builder 11may93jaw |
\ Builder 11may93jaw |
|
|
: Builder ( Create-xt do:-xt "name" -- ) |
: Builder ( Create-xt do-ghost "name" -- ) |
\ builds up a builder in current vocabulary |
\ builds up a builder in current vocabulary |
\ create-xt is executed when word is interpreted |
\ create-xt is executed when word is interpreted |
\ do:-xt is executet when the created word from builder is executed |
\ do:-xt is executet when the created word from builder is executed |
\ for do:-xt an additional entry after the normal ghost-enrys is used |
\ for do:-xt an additional entry after the normal ghost-enrys is used |
|
|
Make-Ghost ( Create-xt do:-xt ghost ) |
Make-Ghost ( Create-xt do-ghost ghost ) |
rot swap ( do:-xt Create-xt ghost ) |
rot swap ( do-ghost Create-xt ghost ) |
>exec ! , ; |
>exec ! , ; |
\ rot swap >exec dup @ ['] NoExec <> |
|
\ IF 2drop ELSE ! THEN , ; |
|
|
|
: gdoes, ( ghost -- ) |
: gdoes, ( ghost -- ) |
\ makes the codefield for a word that is built |
\ makes the codefield for a word that is built |
Line 2009 Cond: DOES> restrict?
|
Line 2047 Cond: DOES> restrict?
|
executed-ghost @ |
executed-ghost @ |
create-forward-warn |
create-forward-warn |
IF ['] reswarn-forward IS resolve-warning THEN |
IF ['] reswarn-forward IS resolve-warning THEN |
Theader >r dup gdoes, |
Theader >r dup , dup gdoes, |
\ stores execution semantic in the built word |
\ stores execution semantic in the built word |
\ if the word already has a semantic (concerns S", IS, .", DOES>) |
\ if the word already has a semantic (concerns S", IS, .", DOES>) |
\ then keep it |
\ then keep it |
>end @ >exec @ r> >exec dup @ ['] NoExec = |
>end @ |
IF ! ELSE 2drop THEN ; |
dup >exec @ r@ >exec dup @ ['] NoExec = IF ! ELSE 2drop THEN |
|
>comp @ r> >comp ! ; |
|
|
: RTCreate ( <name> -- ) |
: RTCreate ( <name> -- ) |
\ creates a new word with code-field in ram |
\ creates a new word with code-field in ram |
Line 2022 Cond: DOES> restrict?
|
Line 2061 Cond: DOES> restrict?
|
create-forward-warn |
create-forward-warn |
IF ['] reswarn-forward IS resolve-warning THEN |
IF ['] reswarn-forward IS resolve-warning THEN |
\ make Alias |
\ make Alias |
(THeader there 0 T a, H 80 flag! ( S executed-ghost new-ghost ) |
(THeader there 0 T a, H alias-mask flag! ( S executed-ghost new-ghost ) |
\ store poiter to code-field |
\ store poiter to code-field |
switchram T cfalign H |
switchram T cfalign H |
there swap T ! H |
there swap T ! H |
Line 2049 Cond: DOES> restrict?
|
Line 2088 Cond: DOES> restrict?
|
: gdoes> ( ghost -- addr flag ) |
: gdoes> ( ghost -- addr flag ) |
executed-ghost @ |
executed-ghost @ |
state @ IF gexecute true EXIT THEN |
state @ IF gexecute true EXIT THEN |
>link @ T >body H false ; |
g>body false ; |
|
|
\ DO: ;DO 11may93jaw |
\ DO: ;DO 11may93jaw |
\ changed to ?EXIT 10may93jaw |
\ changed to ?EXIT 10may93jaw |
|
|
: DO: ( -- addr [xt] [colon-sys] ) |
: DO: ( -- ghost [xt] [colon-sys] ) |
here ghostheader |
here ghostheader |
:noname postpone gdoes> postpone ?EXIT ; |
:noname postpone gdoes> postpone ?EXIT ; |
|
|
: by: ( -- addr [xt] [colon-sys] ) \ name |
: by: ( -- ghost [xt] [colon-sys] ) \ name |
ghost |
ghost |
:noname postpone gdoes> postpone ?EXIT ; |
:noname postpone gdoes> postpone ?EXIT ; |
|
|
: ;DO ( addr [xt] [colon-sys] -- addr ) |
: ;DO ( ghost [xt] [colon-sys] -- ghost ) |
postpone ; ( S addr xt ) |
postpone ; ( S addr xt ) |
over >exec ! ; immediate |
over >exec ! ; immediate |
|
|
: by ( -- addr ) \ Name |
T has? peephole H [IF] |
|
: compile: ( ghost -- ghost [xt] [colon-sys] ) |
|
:noname postpone g>body ; |
|
: ;compile ( ghost [xt] [colon-sys] -- ghost ) |
|
postpone ; over >comp ! ; immediate |
|
[ELSE] |
|
: compile: ( ghost -- ghost xt colon-sys ) :noname ; |
|
: ;compile ( ghost xt colon-sys -- ghost ) |
|
postpone ; drop ; immediate |
|
[THEN] |
|
|
|
: by ( -- ghost ) \ Name |
ghost >end @ ; |
ghost >end @ ; |
|
|
>TARGET |
>TARGET |
Line 2074 Cond: DOES> restrict?
|
Line 2124 Cond: DOES> restrict?
|
|
|
Build: ( n -- ) ; |
Build: ( n -- ) ; |
by: :docon ( ghost -- n ) T @ H ;DO |
by: :docon ( ghost -- n ) T @ H ;DO |
|
compile: alit, compile @ ;compile |
Builder (Constant) |
Builder (Constant) |
|
|
Build: ( n -- ) T , H ; |
Build: ( n -- ) T , H ; |
Line 2090 Builder 2Constant
|
Line 2141 Builder 2Constant
|
|
|
BuildSmart: ; |
BuildSmart: ; |
by: :dovar ( ghost -- addr ) ;DO |
by: :dovar ( ghost -- addr ) ;DO |
|
\ compile: alit, ;compile |
Builder Create |
Builder Create |
|
|
T has? rom H [IF] |
T has? rom H [IF] |
Line 2099 Builder Variable
|
Line 2151 Builder Variable
|
[ELSE] |
[ELSE] |
Build: T 0 , H ; |
Build: T 0 , H ; |
by Create |
by Create |
|
\ compile: alit, ;compile |
Builder Variable |
Builder Variable |
[THEN] |
[THEN] |
|
|
Line 2109 Builder 2Variable
|
Line 2162 Builder 2Variable
|
[ELSE] |
[ELSE] |
Build: T 0 , 0 , H ; |
Build: T 0 , 0 , H ; |
by Create |
by Create |
|
\ compile: alit, ;compile |
Builder 2Variable |
Builder 2Variable |
[THEN] |
[THEN] |
|
|
Line 2119 Builder AVariable
|
Line 2173 Builder AVariable
|
[ELSE] |
[ELSE] |
Build: T 0 A, H ; |
Build: T 0 A, H ; |
by Create |
by Create |
|
\ compile: alit, ;compile |
Builder AVariable |
Builder AVariable |
[THEN] |
[THEN] |
|
|
Line 2141 Variable tudp 0 tudp !
|
Line 2196 Variable tudp 0 tudp !
|
|
|
Build: 0 u, X , ; |
Build: 0 u, X , ; |
by: :douser ( ghost -- up-addr ) X @ tup @ + ;DO |
by: :douser ( ghost -- up-addr ) X @ tup @ + ;DO |
|
compile: compile useraddr T @ , H ;compile |
Builder User |
Builder User |
|
|
Build: 0 u, X , 0 u, drop ; |
Build: 0 u, X , 0 u, drop ; |
Line 2161 Builder AValue
|
Line 2217 Builder AValue
|
|
|
BuildSmart: ( -- ) [T'] noop T A, H ; |
BuildSmart: ( -- ) [T'] noop T A, H ; |
by: :dodefer ( ghost -- ) ABORT" CROSS: Don't execute" ;DO |
by: :dodefer ( ghost -- ) ABORT" CROSS: Don't execute" ;DO |
|
compile: alit, compile @ compile execute ;compile |
Builder Defer |
Builder Defer |
|
|
Build: ( inter comp -- ) swap T immediate A, A, H ; |
Build: ( inter comp -- ) swap T immediate A, A, H ; |
Line 2177 Builder interpret/compile:
|
Line 2234 Builder interpret/compile:
|
|
|
Build: ; |
Build: ; |
by: :dofield T @ H + ;DO |
by: :dofield T @ H + ;DO |
|
compile: T @ H lit, compile + ;compile |
Builder (Field) |
Builder (Field) |
|
|
Build: ( align1 offset1 align size "name" -- align2 offset2 ) |
Build: ( align1 offset1 align size "name" -- align2 offset2 ) |
Line 2191 Builder Field
|
Line 2249 Builder Field
|
: cell% ( n -- size align ) |
: cell% ( n -- size align ) |
T 1 cells H dup ; |
T 1 cells H dup ; |
|
|
|
Build: ( m v -- m' v ) dup T , cell+ H ; |
|
DO: abort" Not in cross mode" ;DO |
|
Builder input-method |
|
|
|
Build: ( m v size -- m v' ) over T , H + ; |
|
DO: abort" Not in cross mode" ;DO |
|
Builder input-var |
|
|
\ structural conditionals 17dec92py |
\ structural conditionals 17dec92py |
|
|
>CROSS |
>CROSS |
Line 2339 Cond: NEXT restrict? sys? next, ;Cond
|
Line 2405 Cond: NEXT restrict? sys? next, ;Cond
|
|
|
: ," [char] " parse T string, align H ; |
: ," [char] " parse T string, align H ; |
|
|
Cond: ." restrict? compile (.") T ," H ;Cond |
Cond: ." restrict? compile (.") T ," H ;Cond ( " ) |
Cond: S" restrict? compile (S") T ," H ;Cond |
Cond: S" restrict? compile (S") T ," H ;Cond ( " ) |
Cond: ABORT" restrict? compile (ABORT") T ," H ;Cond |
Cond: ABORT" restrict? compile (ABORT") T ," H ;Cond ( " ) |
|
|
Cond: IS T ' >body H compile ALiteral compile ! ;Cond |
Cond: IS T ' >body H compile ALiteral compile ! ;Cond |
: IS T >address ' >body ! H ; |
: IS T >address ' >body ! H ; |